{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/huang/sympy_work_code'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "%pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sys import path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/home/huang/sympy_work_code',\n",
       " '/home/huang/anaconda3/envs/learn-sympy/lib/python312.zip',\n",
       " '/home/huang/anaconda3/envs/learn-sympy/lib/python3.12',\n",
       " '/home/huang/anaconda3/envs/learn-sympy/lib/python3.12/lib-dynload',\n",
       " '',\n",
       " '/home/huang/anaconda3/envs/learn-sympy/lib/python3.12/site-packages']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "path.append(\"/home/huang/Documents/sympy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load \"./environment.py\"\n",
    "# You must import sympy.abc first then import sympy\n",
    "# or it will have some bugs when it run solvers for \n",
    "# trigeometric functions.\n",
    "from sympy.abc import x,y,z,t,k,l,n,m,p,q\n",
    "from sympy import *\n",
    "from sympy.calculus.util import *\n",
    "from sympy.stats import *\n",
    "\n",
    "from sys import path,platform\n",
    "match platform:\n",
    "    case \"linux\":\n",
    "        path.append(\"/home/huang/Documents/packaging_tutorial/src\")\n",
    "    case \"darwin\":\n",
    "        path.append(\"/Users/huangzhiming/Documents/python学习/packaging_tutorial/src\")\n",
    "%load_ext autoreload \n",
    "%autoreload 1\n",
    "\n",
    "%aimport basic_package.utils\n",
    "%aimport function_calculator_package.extreme_points\n",
    "%aimport function_calculator_package.utils\n",
    "%aimport quadratic_function.utils\n",
    "%aimport quadratic_function.hyperbola\n",
    "%aimport quadratic_function.utils\n",
    "\n",
    "from basic_package.utils import *\n",
    "from function_calculator_package.extreme_points import *\n",
    "from function_calculator_package.utils import *\n",
    "from quadratic_function.quadraticfunction import QuadraticFunction\n",
    "from quadratic_function.hyperbola import Hyperbola\n",
    "from quadratic_function.utils import line_and_quadratic\n",
    "\n",
    "%aimport excel_function_package.chi_square_test\n",
    "from excel_function_package.chi_square_test import ChiSquaredTest,chi_squared_of_error_probability\n",
    "%aimport excel_function_package.data\n",
    "from excel_function_package.data import Data\n",
    "\n",
    "%aimport solver.utils\n",
    "from solver.utils import solve_univariate_inequalities\n",
    "\n",
    "%aimport function_calculator_package.utils \n",
    "from function_calculator_package.utils import function_is_odd,function_is_even\n",
    "\n",
    "%aimport geometry3D.frustum\n",
    "%aimport geometry3D.prism\n",
    "%aimport geometry3D.pyramid\n",
    "%aimport geometry3D.frustum_cone\n",
    "%aimport geometry3D.sphere\n",
    "\n",
    "from geometry3D.frustum import Frustum\n",
    "from geometry3D.prism import Prism,Cube,Cylinder\n",
    "from geometry3D.pyramid import Pyramid,Cone,Tetrahedron\n",
    "from geometry3D.frustum_cone import FrustumCone\n",
    "from geometry3D.sphere import Sphere\n",
    "a,b,c=symbols(\"a,b,c\",real=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.core import Basic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "init_printing(use_latex=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport excel_function_package.linear_regression\n",
    "from excel_function_package.linear_regression import LinearRegression\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Hi(Symbol):\n",
    "    def __new__(cls,name,*args,**kwargs):\n",
    "        \n",
    "        instance= Basic.__new__(cls,name,*args)\n",
    "        instance._assumptions0=kwargs\n",
    "\n",
    "        return instance\n",
    "    \n",
    "    @property\n",
    "    def name(self):\n",
    "        return self.args[0]\n",
    "    def __repr__(self):\n",
    "        print(\"hi's __repr__\")\n",
    "        return \"hello\"\n",
    "    def __str__(self):\n",
    "        return \"Hi\"\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=Hi(\"huang\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi's __repr__\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle huang$"
      ],
      "text/plain": [
       "hello"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class MySymbol(Symbol):\n",
    "    \"\"\"\n",
    "    自定义符号类，模仿 SymPy 的 Symbol 类。\n",
    "    \"\"\"\n",
    "    is_Symbol = True\n",
    "    is_Atom = True\n",
    "    def __new__(cls, name, n,**assumptions):\n",
    "        \"\"\"\n",
    "        创建一个新的符号实例。\n",
    "        \"\"\"\n",
    "        # symbol=sympify(name)\n",
    "        obj = Basic.__new__(cls, name,n)\n",
    "        return obj\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    def __hash__(self):\n",
    "        \"\"\"\n",
    "        提供符号的哈希值。\n",
    "        \"\"\"\n",
    "        return hash((self.name,))\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        \"\"\"\n",
    "        比较两个符号是否相等。\n",
    "        \"\"\"\n",
    "        return isinstance(other, MySymbol) and self.name == other.name\n",
    "\n",
    "    @property\n",
    "    def name(self):\n",
    "        \"\"\"\n",
    "        返回符号的名称。\n",
    "        \"\"\"\n",
    "        return str(self.args[0])\n",
    "    @property\n",
    "    def value(self):\n",
    "        return self.args[1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# 使用自定义符号类\n",
    "x = MySymbol('x', 2,positive=True, integer=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x$"
      ],
      "text/plain": [
       "x"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = MatrixSymbol('A', 5, 5)\n",
    "B = MatrixSymbol('B', 5, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle A + B$"
      ],
      "text/plain": [
       "A + B"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A+B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "from sympy import symbols, sin, cos, simplify, strategies\n",
    "\n",
    "x = symbols('x')\n",
    "\n",
    "expr = sin(x)**2 + cos(x)**2\n",
    "\n",
    "# 使用内置的 simplify 策略\n",
    "simplified_expr = simplify(expr, strategies=[strategies.core])\n",
    "print(simplified_expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sin^{2}{\\left(x \\right)} + \\cos^{2}{\\left(x \\right)}$"
      ],
      "text/plain": [
       "sin(x)**2 + cos(x)**2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sin(x) + sin(sin(x)) + cos(x)\n"
     ]
    }
   ],
   "source": [
    "from sympy import symbols, sin, cos, simplify\n",
    "from sympy.strategies import exhaust\n",
    "\n",
    "# 定义符号\n",
    "x = symbols('x')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# 定义一个表达式\n",
    "expr = sin(x)  + cos(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cos(sin(x))\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 定义一个自定义策略函数，用于将表达式中的 sin(x) 替换为 cos(x)\n",
    "def replace_sin_with_cos(expr):\n",
    "    # 如果表达式是 sin 类型，则替换为 cos\n",
    "    if isinstance(expr, sin):\n",
    "        return cos(expr.args[0])\n",
    "    # 否则，递归地对表达式的参数应用策略\n",
    "    return expr\n",
    "\n",
    "# 使用 exhaust 应用自定义策略\n",
    "new_expr = exhaust(replace_sin_with_cos)(sin(sin(x)))\n",
    "\n",
    "print(new_expr)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\cos{\\left(\\sin{\\left(x \\right)} \\right)}$"
      ],
      "text/plain": [
       "cos(sin(x))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=3/sin(x)+tan(x)/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\tan{\\left(x \\right)}}{3} + \\frac{3}{\\sin{\\left(x \\right)}}$"
      ],
      "text/plain": [
       "tan(x)/3 + 3/sin(x)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(0, \\frac{2 \\pi}{3}\\right)$"
      ],
      "text/plain": [
       "Interval.open(0, 2*pi/3)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Interval.open(0,2*pi/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Cannot iterate over symbolic Range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31m_SolveTrig1Error\u001b[0m                          Traceback (most recent call last)",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/solvers/solveset.py:612\u001b[0m, in \u001b[0;36m_solve_trig\u001b[0;34m(f, symbol, domain)\u001b[0m\n\u001b[1;32m    611\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 612\u001b[0m     sol \u001b[38;5;241m=\u001b[39m _solve_trig1(f, symbol, domain)\n\u001b[1;32m    613\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m _SolveTrig1Error:\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/solvers/solveset.py:694\u001b[0m, in \u001b[0;36m_solve_trig1\u001b[0;34m(f, symbol, domain)\u001b[0m\n\u001b[1;32m    693\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(s, RootOf) \u001b[38;5;28;01mfor\u001b[39;00m s \u001b[38;5;129;01min\u001b[39;00m solns):\n\u001b[0;32m--> 694\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m _SolveTrig1Error(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpolynomial results in RootOf object\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    695\u001b[0m \u001b[38;5;66;03m# revert the change of variable\u001b[39;00m\n",
      "\u001b[0;31m_SolveTrig1Error\u001b[0m: polynomial results in RootOf object",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[29], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m function_range(expr,x,Interval\u001b[38;5;241m.\u001b[39mopen(pi\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m3\u001b[39m,pi))\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/calculus/util.py:197\u001b[0m, in \u001b[0;36mfunction_range\u001b[0;34m(f, symbol, domain)\u001b[0m\n\u001b[1;32m    194\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    195\u001b[0m         vals \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m FiniteSet(f\u001b[38;5;241m.\u001b[39msubs(symbol, limit_point))\n\u001b[0;32m--> 197\u001b[0m solution \u001b[38;5;241m=\u001b[39m solveset(f\u001b[38;5;241m.\u001b[39mdiff(symbol), symbol, interval)\n\u001b[1;32m    199\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m iterable(solution):\n\u001b[1;32m    200\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m(\n\u001b[1;32m    201\u001b[0m             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mUnable to find critical points for \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mformat(f))\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/solvers/solveset.py:2252\u001b[0m, in \u001b[0;36msolveset\u001b[0;34m(f, symbol, domain)\u001b[0m\n\u001b[1;32m   2250\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m symbol \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m _rc:\n\u001b[1;32m   2251\u001b[0m     x \u001b[38;5;241m=\u001b[39m _rc[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;28;01mif\u001b[39;00m domain\u001b[38;5;241m.\u001b[39mis_subset(S\u001b[38;5;241m.\u001b[39mReals) \u001b[38;5;28;01melse\u001b[39;00m _rc[\u001b[38;5;241m1\u001b[39m]\n\u001b[0;32m-> 2252\u001b[0m     rv \u001b[38;5;241m=\u001b[39m solveset(f\u001b[38;5;241m.\u001b[39mxreplace({symbol: x}), x, domain)\n\u001b[1;32m   2253\u001b[0m     \u001b[38;5;66;03m# try to use the original symbol if possible\u001b[39;00m\n\u001b[1;32m   2254\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/solvers/solveset.py:2276\u001b[0m, in \u001b[0;36msolveset\u001b[0;34m(f, symbol, domain)\u001b[0m\n\u001b[1;32m   2273\u001b[0m     f \u001b[38;5;241m=\u001b[39m f\u001b[38;5;241m.\u001b[39mxreplace({d: e})\n\u001b[1;32m   2274\u001b[0m f \u001b[38;5;241m=\u001b[39m piecewise_fold(f)\n\u001b[0;32m-> 2276\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _solveset(f, symbol, domain, _check\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/solvers/solveset.py:1060\u001b[0m, in \u001b[0;36m_solveset\u001b[0;34m(f, symbol, domain, _check)\u001b[0m\n\u001b[1;32m   1057\u001b[0m     result \u001b[38;5;241m=\u001b[39m Union(\u001b[38;5;241m*\u001b[39m[solver(m, symbol) \u001b[38;5;28;01mfor\u001b[39;00m m \u001b[38;5;129;01min\u001b[39;00m f\u001b[38;5;241m.\u001b[39margs])\n\u001b[1;32m   1058\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m _is_function_class_equation(TrigonometricFunction, f, symbol) \u001b[38;5;129;01mor\u001b[39;00m \\\n\u001b[1;32m   1059\u001b[0m         _is_function_class_equation(HyperbolicFunction, f, symbol):\n\u001b[0;32m-> 1060\u001b[0m     result \u001b[38;5;241m=\u001b[39m _solve_trig(f, symbol, domain)\n\u001b[1;32m   1061\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(f, arg):\n\u001b[1;32m   1062\u001b[0m     a \u001b[38;5;241m=\u001b[39m f\u001b[38;5;241m.\u001b[39margs[\u001b[38;5;241m0\u001b[39m]\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/solvers/solveset.py:615\u001b[0m, in \u001b[0;36m_solve_trig\u001b[0;34m(f, symbol, domain)\u001b[0m\n\u001b[1;32m    613\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m _SolveTrig1Error:\n\u001b[1;32m    614\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 615\u001b[0m         sol \u001b[38;5;241m=\u001b[39m _solve_trig2(f, symbol, domain)\n\u001b[1;32m    616\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m:\n\u001b[1;32m    617\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m(filldedent(\u001b[38;5;124m'''\u001b[39m\n\u001b[1;32m    618\u001b[0m \u001b[38;5;124m            Solution to this kind of trigonometric equations\u001b[39m\n\u001b[1;32m    619\u001b[0m \u001b[38;5;124m            is yet to be implemented\u001b[39m\u001b[38;5;124m'''\u001b[39m))\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/solvers/solveset.py:787\u001b[0m, in \u001b[0;36m_solve_trig2\u001b[0;34m(f, symbol, domain)\u001b[0m\n\u001b[1;32m    785\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m degree(h) \u001b[38;5;241m>\u001b[39m degree(g):                   \u001b[38;5;66;03m# If degree(denom)>degree(num) then there\u001b[39;00m\n\u001b[1;32m    786\u001b[0m         result \u001b[38;5;241m=\u001b[39m Union(result, dsol)            \u001b[38;5;66;03m# would be another sol at Lim(denom-->oo)\u001b[39;00m\n\u001b[0;32m--> 787\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m Intersection(result, domain)\n\u001b[1;32m    788\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m solns \u001b[38;5;129;01mis\u001b[39;00m S\u001b[38;5;241m.\u001b[39mEmptySet:\n\u001b[1;32m    789\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m S\u001b[38;5;241m.\u001b[39mEmptySet\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/sets/sets.py:1486\u001b[0m, in \u001b[0;36mIntersection.__new__\u001b[0;34m(cls, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1484\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m evaluate:\n\u001b[1;32m   1485\u001b[0m     args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m_new_args_filter(args))\n\u001b[0;32m-> 1486\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m simplify_intersection(args)\n\u001b[1;32m   1488\u001b[0m args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(ordered(args, Set\u001b[38;5;241m.\u001b[39m_infimum_key))\n\u001b[1;32m   1490\u001b[0m obj \u001b[38;5;241m=\u001b[39m Basic\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__new__\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;241m*\u001b[39margs)\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/sets/sets.py:2601\u001b[0m, in \u001b[0;36msimplify_intersection\u001b[0;34m(args)\u001b[0m\n\u001b[1;32m   2599\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(other_sets) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m   2600\u001b[0m     other \u001b[38;5;241m=\u001b[39m Intersection(\u001b[38;5;241m*\u001b[39mother_sets)\n\u001b[0;32m-> 2601\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m Union(\u001b[38;5;241m*\u001b[39m(Intersection(arg, other) \u001b[38;5;28;01mfor\u001b[39;00m arg \u001b[38;5;129;01min\u001b[39;00m s\u001b[38;5;241m.\u001b[39margs))\n\u001b[1;32m   2602\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m   2603\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m Union(\u001b[38;5;241m*\u001b[39ms\u001b[38;5;241m.\u001b[39margs)\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/sets/sets.py:2601\u001b[0m, in \u001b[0;36m<genexpr>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m   2599\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(other_sets) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m   2600\u001b[0m     other \u001b[38;5;241m=\u001b[39m Intersection(\u001b[38;5;241m*\u001b[39mother_sets)\n\u001b[0;32m-> 2601\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m Union(\u001b[38;5;241m*\u001b[39m(Intersection(arg, other) \u001b[38;5;28;01mfor\u001b[39;00m arg \u001b[38;5;129;01min\u001b[39;00m s\u001b[38;5;241m.\u001b[39margs))\n\u001b[1;32m   2602\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m   2603\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m Union(\u001b[38;5;241m*\u001b[39ms\u001b[38;5;241m.\u001b[39margs)\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/sets/sets.py:1486\u001b[0m, in \u001b[0;36mIntersection.__new__\u001b[0;34m(cls, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1484\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m evaluate:\n\u001b[1;32m   1485\u001b[0m     args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m_new_args_filter(args))\n\u001b[0;32m-> 1486\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m simplify_intersection(args)\n\u001b[1;32m   1488\u001b[0m args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(ordered(args, Set\u001b[38;5;241m.\u001b[39m_infimum_key))\n\u001b[1;32m   1490\u001b[0m obj \u001b[38;5;241m=\u001b[39m Basic\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__new__\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;241m*\u001b[39margs)\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/sets/sets.py:2624\u001b[0m, in \u001b[0;36msimplify_intersection\u001b[0;34m(args)\u001b[0m\n\u001b[1;32m   2622\u001b[0m new_args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m   2623\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m t \u001b[38;5;129;01min\u001b[39;00m args \u001b[38;5;241m-\u001b[39m {s}:\n\u001b[0;32m-> 2624\u001b[0m     new_set \u001b[38;5;241m=\u001b[39m intersection_sets(s, t)\n\u001b[1;32m   2625\u001b[0m     \u001b[38;5;66;03m# This returns None if s does not know how to intersect\u001b[39;00m\n\u001b[1;32m   2626\u001b[0m     \u001b[38;5;66;03m# with t. Returns the newly intersected set otherwise\u001b[39;00m\n\u001b[1;32m   2628\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m new_set \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/multipledispatch/dispatcher.py:243\u001b[0m, in \u001b[0;36mDispatcher.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    241\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cache[types] \u001b[38;5;241m=\u001b[39m func\n\u001b[1;32m    242\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 243\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    245\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m MDNotImplementedError:\n\u001b[1;32m    246\u001b[0m     funcs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdispatch_iter(\u001b[38;5;241m*\u001b[39mtypes)\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/sets/handlers/intersection.py:398\u001b[0m, in \u001b[0;36m_\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m    396\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m S\u001b[38;5;241m.\u001b[39mEmptySet\n\u001b[1;32m    397\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(range_set, Range) \u001b[38;5;129;01mand\u001b[39;00m range_set\u001b[38;5;241m.\u001b[39msize \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m S\u001b[38;5;241m.\u001b[39mInfinity:\n\u001b[0;32m--> 398\u001b[0m     range_set \u001b[38;5;241m=\u001b[39m FiniteSet(\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mlist\u001b[39m(range_set))\n\u001b[1;32m    400\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m range_set \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    401\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m imageset(Lambda(n, f), range_set)\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/sets/fancysets.py:744\u001b[0m, in \u001b[0;36mRange.__iter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    742\u001b[0m n \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msize  \u001b[38;5;66;03m# validate\u001b[39;00m\n\u001b[1;32m    743\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (n\u001b[38;5;241m.\u001b[39mhas(S\u001b[38;5;241m.\u001b[39mInfinity) \u001b[38;5;129;01mor\u001b[39;00m n\u001b[38;5;241m.\u001b[39mhas(S\u001b[38;5;241m.\u001b[39mNegativeInfinity) \u001b[38;5;129;01mor\u001b[39;00m n\u001b[38;5;241m.\u001b[39mis_Integer):\n\u001b[0;32m--> 744\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCannot iterate over symbolic Range\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    745\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstart \u001b[38;5;129;01min\u001b[39;00m [S\u001b[38;5;241m.\u001b[39mNegativeInfinity, S\u001b[38;5;241m.\u001b[39mInfinity]:\n\u001b[1;32m    746\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCannot iterate over Range with infinite start\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mTypeError\u001b[0m: Cannot iterate over symbolic Range"
     ]
    }
   ],
   "source": [
    "function_range(expr,x,Interval.open(pi/3,pi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x734ef67e6050>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(x,pi/6,pi/2+-.1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x734ee1113bd0>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(x,pi/2+0.01,pi-0.1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{- \\sin^{2}{\\left(x \\right)} \\tan^{2}{\\left(x \\right)} - \\sin^{2}{\\left(x \\right)} + 9 \\cos{\\left(x \\right)}}{3 \\sin^{2}{\\left(x \\right)}}$"
      ],
      "text/plain": [
       "-(-sin(x)**2*tan(x)**2 - sin(x)**2 + 9*cos(x))/(3*sin(x)**2)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{9 \\cos{\\left(x \\right)} - \\tan^{2}{\\left(x \\right)}}{3 \\sin^{2}{\\left(x \\right)}}$"
      ],
      "text/plain": [
       "-(9*cos(x) - tan(x)**2)/(3*sin(x)**2)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trigsimp(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x734ee10fc210>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(9*x**3+x**2-1,(x,-1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\frac{1}{27} + \\frac{1}{729 \\sqrt[3]{\\frac{\\sqrt{6549}}{1458} + \\frac{2185}{39366}}} + \\sqrt[3]{\\frac{\\sqrt{6549}}{1458} + \\frac{2185}{39366}}\\right\\}$"
      ],
      "text/plain": [
       "{-1/27 + 1/(729*(sqrt(6549)/1458 + 2185/39366)**(1/3)) + (sqrt(6549)/1458 + 2185/39366)**(1/3)}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(9*x**3+x**2-1,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=list(_)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{1}{27} + \\frac{1}{729 \\sqrt[3]{\\frac{\\sqrt{6549}}{1458} + \\frac{2185}{39366}}} + \\sqrt[3]{\\frac{\\sqrt{6549}}{1458} + \\frac{2185}{39366}}$"
      ],
      "text/plain": [
       "-1/27 + 1/(729*(sqrt(6549)/1458 + 2185/39366)**(1/3)) + (sqrt(6549)/1458 + 2185/39366)**(1/3)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "sin_c=sqrt(9*answer**3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3 \\left(- \\frac{1}{27} + \\frac{1}{729 \\sqrt[3]{\\frac{\\sqrt{6549}}{1458} + \\frac{2185}{39366}}} + \\sqrt[3]{\\frac{\\sqrt{6549}}{1458} + \\frac{2185}{39366}}\\right)^{\\frac{3}{2}}$"
      ],
      "text/plain": [
       "3*(-1/27 + 1/(729*(sqrt(6549)/1458 + 2185/39366)**(1/3)) + (sqrt(6549)/1458 + 2185/39366)**(1/3))**(3/2)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin_c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "tan_c=sqrt(1/answer**2-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{-1 + \\frac{1}{\\left(- \\frac{1}{27} + \\frac{1}{729 \\sqrt[3]{\\frac{\\sqrt{6549}}{1458} + \\frac{2185}{39366}}} + \\sqrt[3]{\\frac{\\sqrt{6549}}{1458} + \\frac{2185}{39366}}\\right)^{2}}}$"
      ],
      "text/plain": [
       "sqrt(-1 + (-1/27 + 1/(729*(sqrt(6549)/1458 + 2185/39366)**(1/3)) + (sqrt(6549)/1458 + 2185/39366)**(1/3))**(-2))"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tan_c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{-1 + \\frac{1}{\\left(- \\frac{1}{27} + \\frac{1}{729 \\sqrt[3]{\\frac{\\sqrt{6549}}{1458} + \\frac{2185}{39366}}} + \\sqrt[3]{\\frac{\\sqrt{6549}}{1458} + \\frac{2185}{39366}}\\right)^{2}}}}{3} + \\frac{1}{\\left(- \\frac{1}{27} + \\frac{1}{729 \\sqrt[3]{\\frac{\\sqrt{6549}}{1458} + \\frac{2185}{39366}}} + \\sqrt[3]{\\frac{\\sqrt{6549}}{1458} + \\frac{2185}{39366}}\\right)^{\\frac{3}{2}}}$"
      ],
      "text/plain": [
       "sqrt(-1 + (-1/27 + 1/(729*(sqrt(6549)/1458 + 2185/39366)**(1/3)) + (sqrt(6549)/1458 + 2185/39366)**(1/3))**(-2))/3 + (-1/27 + 1/(729*(sqrt(6549)/1458 + 2185/39366)**(1/3)) + (sqrt(6549)/1458 + 2185/39366)**(1/3))**(-3/2)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs({sin(x):sin_c,tan(x):tan_c})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4.02076402755079$"
      ],
      "text/plain": [
       "4.02076402755079"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Game():\n",
    "    def __init__(self,name):\n",
    "        self.name=name\n",
    "    @property\n",
    "    def __hello__(self):\n",
    "        print(f\"Hello,{self.name}!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "hi=Game(\"huang\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello,huang!\n"
     ]
    }
   ],
   "source": [
    "hi.__hello__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2)\n",
      "((1, 2), {'extral': True})\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        instance = super().__new__(cls)\n",
    "        instance.args = args\n",
    "        instance.kwargs = kwargs\n",
    "        return instance\n",
    "\n",
    "    def __getnewargs__(self):\n",
    "        return self.args\n",
    "\n",
    "    def __getnewargs_ex__(self):\n",
    "        return (self.args, {k: v for k, v in self.kwargs.items() if k != 'extra'})\n",
    "\n",
    "# 创建对象\n",
    "obj = MyClass(1, 2, extral=True)\n",
    "\n",
    "# 使用 __getnewargs__ 获取创建对象时的参数\n",
    "print(obj.__getnewargs__())  # 输出: (1, 2)\n",
    "\n",
    "# 如果需要处理额外的关键字参数\n",
    "print(obj.__getnewargs_ex__())  # 输出: (<arguments>, { 'extra': True })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Symbol in module sympy.core.symbol:\n",
      "\n",
      "class Symbol(sympy.core.expr.AtomicExpr, sympy.logic.boolalg.Boolean)\n",
      " |  Symbol(name, **assumptions)\n",
      " |  \n",
      " |  Assumptions:\n",
      " |     commutative = True\n",
      " |  \n",
      " |  You can override the default assumptions in the constructor.\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import symbols\n",
      " |  >>> A,B = symbols('A,B', commutative = False)\n",
      " |  >>> bool(A*B != B*A)\n",
      " |  True\n",
      " |  >>> bool(A*B*2 == 2*A*B) == True # multiplication by scalars is commutative\n",
      " |  True\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Symbol\n",
      " |      sympy.core.expr.AtomicExpr\n",
      " |      sympy.core.basic.Atom\n",
      " |      sympy.core.expr.Expr\n",
      " |      sympy.logic.boolalg.Boolean\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __getnewargs_ex__(self)\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  as_real_imag(self, deep=True, **hints)\n",
      " |      Performs complex expansion on 'self' and returns a tuple\n",
      " |      containing collected both real and imaginary parts. This\n",
      " |      method cannot be confused with re() and im() functions,\n",
      " |      which does not perform complex expansion at evaluation.\n",
      " |      \n",
      " |      However it is possible to expand both re() and im()\n",
      " |      functions and get exactly the same results as with\n",
      " |      a single call to this function.\n",
      " |      \n",
      " |      >>> from sympy import symbols, I\n",
      " |      \n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |      \n",
      " |      >>> (x + y*I).as_real_imag()\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> from sympy.abc import z, w\n",
      " |      \n",
      " |      >>> (z + w*I).as_real_imag()\n",
      " |      (re(z) - im(w), re(w) + im(z))\n",
      " |  \n",
      " |  as_set(self)\n",
      " |      Rewrites Boolean expression in terms of real sets.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, Eq, Or, And\n",
      " |      >>> x = Symbol('x', real=True)\n",
      " |      >>> Eq(x, 0).as_set()\n",
      " |      {0}\n",
      " |      >>> (x > 0).as_set()\n",
      " |      Interval.open(0, oo)\n",
      " |      >>> And(-2 < x, x < 2).as_set()\n",
      " |      Interval.open(-2, 2)\n",
      " |      >>> Or(x < -2, 2 < x).as_set()\n",
      " |      Union(Interval.open(-oo, -2), Interval.open(2, oo))\n",
      " |  \n",
      " |  is_constant(self, *wrt, **flags)\n",
      " |      Return True if self is constant, False if not, or None if\n",
      " |      the constancy could not be determined conclusively.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If an expression has no free symbols then it is a constant. If\n",
      " |      there are free symbols it is possible that the expression is a\n",
      " |      constant, perhaps (but not necessarily) zero. To test such\n",
      " |      expressions, a few strategies are tried:\n",
      " |      \n",
      " |      1) numerical evaluation at two random points. If two such evaluations\n",
      " |      give two different values and the values have a precision greater than\n",
      " |      1 then self is not constant. If the evaluations agree or could not be\n",
      " |      obtained with any precision, no decision is made. The numerical testing\n",
      " |      is done only if ``wrt`` is different than the free symbols.\n",
      " |      \n",
      " |      2) differentiation with respect to variables in 'wrt' (or all free\n",
      " |      symbols if omitted) to see if the expression is constant or not. This\n",
      " |      will not always lead to an expression that is zero even though an\n",
      " |      expression is constant (see added test in test_expr.py). If\n",
      " |      all derivatives are zero then self is constant with respect to the\n",
      " |      given symbols.\n",
      " |      \n",
      " |      3) finding out zeros of denominator expression with free_symbols.\n",
      " |      It will not be constant if there are zeros. It gives more negative\n",
      " |      answers for expression that are not constant.\n",
      " |      \n",
      " |      If neither evaluation nor differentiation can prove the expression is\n",
      " |      constant, None is returned unless two numerical values happened to be\n",
      " |      the same and the flag ``failing_number`` is True -- in that case the\n",
      " |      numerical value will be returned.\n",
      " |      \n",
      " |      If flag simplify=False is passed, self will not be simplified;\n",
      " |      the default is True since self should be simplified before testing.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, Sum, S, pi\n",
      " |      >>> from sympy.abc import a, n, x, y\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> S(2).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, 10)).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant()\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(y)\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(n)\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(x)\n",
      " |      True\n",
      " |      >>> eq = a*cos(x)**2 + a*sin(x)**2 - a\n",
      " |      >>> eq.is_constant()\n",
      " |      True\n",
      " |      >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0\n",
      " |      True\n",
      " |      \n",
      " |      >>> (0**x).is_constant()\n",
      " |      False\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> (x**x).is_constant()\n",
      " |      False\n",
      " |      >>> one = cos(x)**2 + sin(x)**2\n",
      " |      >>> one.is_constant()\n",
      " |      True\n",
      " |      >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1\n",
      " |      True\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(cls, name, **assumptions)\n",
      " |      Symbols are identified by name and assumptions::\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> Symbol(\"x\") == Symbol(\"x\")\n",
      " |      True\n",
      " |      >>> Symbol(\"x\", real=True) == Symbol(\"x\", real=False)\n",
      " |      False\n",
      " |  \n",
      " |  __xnew__(cls, name, **assumptions)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  binary_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  kind\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  name\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __annotations__ = {'name': 'str'}\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  is_Symbol = True\n",
      " |  \n",
      " |  is_comparable = False\n",
      " |  \n",
      " |  is_symbol = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.expr.AtomicExpr:\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |      Like ``free_symbols``, but returns the free symbols only if\n",
      " |      they are contained in an expression node.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (x + y).expr_free_symbols # doctest: +SKIP\n",
      " |      {x, y}\n",
      " |      \n",
      " |      If the expression is contained in a non-expression object, do not return\n",
      " |      the free symbols. Compare:\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> t = Tuple(x + y)\n",
      " |      >>> t.expr_free_symbols # doctest: +SKIP\n",
      " |      set()\n",
      " |      >>> t.free_symbols\n",
      " |      {x, y}\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.expr.AtomicExpr:\n",
      " |  \n",
      " |  is_Atom = True\n",
      " |  \n",
      " |  is_number = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Atom:\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  xreplace(self, rule, hack2=False)\n",
      " |      Replace occurrences of objects within the expression.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      rule : dict-like\n",
      " |          Expresses a replacement rule\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      xreplace : the result of the replacement\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, pi, exp\n",
      " |      >>> x, y, z = symbols('x y z')\n",
      " |      >>> (1 + x*y).xreplace({x: pi})\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).xreplace({x: pi, y: 2})\n",
      " |      1 + 2*pi\n",
      " |      \n",
      " |      Replacements occur only if an entire node in the expression tree is\n",
      " |      matched:\n",
      " |      \n",
      " |      >>> (x*y + z).xreplace({x*y: pi})\n",
      " |      z + pi\n",
      " |      >>> (x*y*z).xreplace({x*y: pi})\n",
      " |      x*y*z\n",
      " |      >>> (2*x).xreplace({2*x: y, x: z})\n",
      " |      y\n",
      " |      >>> (2*2*x).xreplace({2*x: y, x: z})\n",
      " |      4*z\n",
      " |      >>> (x + y + 2).xreplace({x + y: 2})\n",
      " |      x + y + 2\n",
      " |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})\n",
      " |      x + exp(y) + 2\n",
      " |      \n",
      " |      xreplace does not differentiate between free and bound symbols. In the\n",
      " |      following, subs(x, y) would not change x since it is a bound symbol,\n",
      " |      but xreplace does:\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})\n",
      " |      Integral(y, (y, 1, 2*y))\n",
      " |      \n",
      " |      Trying to replace x with an expression raises an error:\n",
      " |      \n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP\n",
      " |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Atom:\n",
      " |  \n",
      " |  class_key() from builtins.type\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  __abs__(self) -> 'Expr'\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __complex__(self)\n",
      " |  \n",
      " |  __divmod__(self, other)\n",
      " |  \n",
      " |  __float__(self)\n",
      " |  \n",
      " |  __floordiv__(self, other)\n",
      " |  \n",
      " |  __format__(self, format_spec: 'str')\n",
      " |      Default object formatter.\n",
      " |  \n",
      " |  __ge__(self, other)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __gt__(self, other)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __int__(self)\n",
      " |  \n",
      " |  __le__(self, other)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lt__(self, other)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __neg__(self)\n",
      " |  \n",
      " |  __pos__(self)\n",
      " |  \n",
      " |  __pow__(self, other, mod=None) -> 'Expr'\n",
      " |  \n",
      " |  __radd__(self, other)\n",
      " |  \n",
      " |  __rdivmod__(self, other)\n",
      " |  \n",
      " |  __rfloordiv__(self, other)\n",
      " |  \n",
      " |  __rmod__(self, other)\n",
      " |  \n",
      " |  __rmul__(self, other)\n",
      " |  \n",
      " |  __round__ = round(self, n=None)\n",
      " |  \n",
      " |  __rpow__(self, other)\n",
      " |  \n",
      " |  __rsub__(self, other)\n",
      " |  \n",
      " |  __rtruediv__(self, other)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __truediv__(self, other)\n",
      " |  \n",
      " |  __trunc__(self)\n",
      " |  \n",
      " |  adjoint(self)\n",
      " |  \n",
      " |  apart(self, x=None, **args)\n",
      " |      See the apart function in sympy.polys\n",
      " |  \n",
      " |  args_cnc(self, cset=False, warn=True, split_1=True)\n",
      " |      Return [commutative factors, non-commutative factors] of self.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      self is treated as a Mul and the ordering of the factors is maintained.\n",
      " |      If ``cset`` is True the commutative factors will be returned in a set.\n",
      " |      If there were repeated factors (as may happen with an unevaluated Mul)\n",
      " |      then an error will be raised unless it is explicitly suppressed by\n",
      " |      setting ``warn`` to False.\n",
      " |      \n",
      " |      Note: -1 is always separated from a Number unless split_1 is False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, oo\n",
      " |      >>> A, B = symbols('A B', commutative=0)\n",
      " |      >>> x, y = symbols('x y')\n",
      " |      >>> (-2*x*y).args_cnc()\n",
      " |      [[-1, 2, x, y], []]\n",
      " |      >>> (-2.5*x).args_cnc()\n",
      " |      [[-1, 2.5, x], []]\n",
      " |      >>> (-2*x*A*B*y).args_cnc()\n",
      " |      [[-1, 2, x, y], [A, B]]\n",
      " |      >>> (-2*x*A*B*y).args_cnc(split_1=False)\n",
      " |      [[-2, x, y], [A, B]]\n",
      " |      >>> (-2*x*y).args_cnc(cset=True)\n",
      " |      [{-1, 2, x, y}, []]\n",
      " |      \n",
      " |      The arg is always treated as a Mul:\n",
      " |      \n",
      " |      >>> (-2 + x + A).args_cnc()\n",
      " |      [[], [x - 2 + A]]\n",
      " |      >>> (-oo).args_cnc() # -oo is a singleton\n",
      " |      [[-1, oo], []]\n",
      " |  \n",
      " |  as_base_exp(self) -> 'tuple[Expr, Expr]'\n",
      " |  \n",
      " |  as_coeff_Add(self, rational=False) -> \"tuple['Number', Expr]\"\n",
      " |      Efficiently extract the coefficient of a summation.\n",
      " |  \n",
      " |  as_coeff_Mul(self, rational: 'bool' = False) -> \"tuple['Number', Expr]\"\n",
      " |      Efficiently extract the coefficient of a product.\n",
      " |  \n",
      " |  as_coeff_add(self, *deps) -> 'tuple[Expr, tuple[Expr, ...]]'\n",
      " |      Return the tuple (c, args) where self is written as an Add, ``a``.\n",
      " |      \n",
      " |      c should be a Rational added to any terms of the Add that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other terms of ``a``; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is an Add or not but\n",
      " |      you want to treat self as an Add or if you want to process the\n",
      " |      individual arguments of the tail of self as an Add.\n",
      " |      \n",
      " |      - if you know self is an Add and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail.\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_add()\n",
      " |      (3, ())\n",
      " |      >>> (3 + x).as_coeff_add()\n",
      " |      (3, (x,))\n",
      " |      >>> (3 + x + y).as_coeff_add(x)\n",
      " |      (y + 3, (x,))\n",
      " |      >>> (3 + y).as_coeff_add(x)\n",
      " |      (y + 3, ())\n",
      " |  \n",
      " |  as_coeff_exponent(self, x) -> 'tuple[Expr, Expr]'\n",
      " |      ``c*x**e -> c,e`` where x can be any symbolic expression.\n",
      " |  \n",
      " |  as_coeff_mul(self, *deps, **kwargs) -> 'tuple[Expr, tuple[Expr, ...]]'\n",
      " |      Return the tuple (c, args) where self is written as a Mul, ``m``.\n",
      " |      \n",
      " |      c should be a Rational multiplied by any factors of the Mul that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other factors of m; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is a Mul or not but\n",
      " |      you want to treat self as a Mul or if you want to process the\n",
      " |      individual arguments of the tail of self as a Mul.\n",
      " |      \n",
      " |      - if you know self is a Mul and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail;\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_mul()\n",
      " |      (3, ())\n",
      " |      >>> (3*x*y).as_coeff_mul()\n",
      " |      (3, (x, y))\n",
      " |      >>> (3*x*y).as_coeff_mul(x)\n",
      " |      (3*y, (x,))\n",
      " |      >>> (3*y).as_coeff_mul(x)\n",
      " |      (3*y, ())\n",
      " |  \n",
      " |  as_coefficient(self, expr)\n",
      " |      Extracts symbolic coefficient at the given expression. In\n",
      " |      other words, this functions separates 'self' into the product\n",
      " |      of 'expr' and 'expr'-free coefficient. If such separation\n",
      " |      is not possible it will return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import E, pi, sin, I, Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> E.as_coefficient(E)\n",
      " |      1\n",
      " |      >>> (2*E).as_coefficient(E)\n",
      " |      2\n",
      " |      >>> (2*sin(E)*E).as_coefficient(E)\n",
      " |      \n",
      " |      Two terms have E in them so a sum is returned. (If one were\n",
      " |      desiring the coefficient of the term exactly matching E then\n",
      " |      the constant from the returned expression could be selected.\n",
      " |      Or, for greater precision, a method of Poly can be used to\n",
      " |      indicate the desired term from which the coefficient is\n",
      " |      desired.)\n",
      " |      \n",
      " |      >>> (2*E + x*E).as_coefficient(E)\n",
      " |      x + 2\n",
      " |      >>> _.args[0]  # just want the exact match\n",
      " |      2\n",
      " |      >>> p = Poly(2*E + x*E); p\n",
      " |      Poly(x*E + 2*E, x, E, domain='ZZ')\n",
      " |      >>> p.coeff_monomial(E)\n",
      " |      2\n",
      " |      >>> p.nth(0, 1)\n",
      " |      2\n",
      " |      \n",
      " |      Since the following cannot be written as a product containing\n",
      " |      E as a factor, None is returned. (If the coefficient ``2*x`` is\n",
      " |      desired then the ``coeff`` method should be used.)\n",
      " |      \n",
      " |      >>> (2*E*x + x).as_coefficient(E)\n",
      " |      >>> (2*E*x + x).coeff(E)\n",
      " |      2*x\n",
      " |      \n",
      " |      >>> (E*(x + 1) + x).as_coefficient(E)\n",
      " |      \n",
      " |      >>> (2*pi*I).as_coefficient(pi*I)\n",
      " |      2\n",
      " |      >>> (2*I).as_coefficient(pi*I)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      coeff: return sum of terms have a given factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  as_coefficients_dict(self, *syms)\n",
      " |      Return a dictionary mapping terms to their Rational coefficient.\n",
      " |      Since the dictionary is a defaultdict, inquiries about terms which\n",
      " |      were not present will return a coefficient of 0.\n",
      " |      \n",
      " |      If symbols ``syms`` are provided, any multiplicative terms\n",
      " |      independent of them will be considered a coefficient and a\n",
      " |      regular dictionary of syms-dependent generators as keys and\n",
      " |      their corresponding coefficients as values will be returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import a, x, y\n",
      " |      >>> (3*x + a*x + 4).as_coefficients_dict()\n",
      " |      {1: 4, x: 3, a*x: 1}\n",
      " |      >>> _[a]\n",
      " |      0\n",
      " |      >>> (3*a*x).as_coefficients_dict()\n",
      " |      {a*x: 3}\n",
      " |      >>> (3*a*x).as_coefficients_dict(x)\n",
      " |      {x: 3*a}\n",
      " |      >>> (3*a*x).as_coefficients_dict(y)\n",
      " |      {1: 3*a*x}\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      This method should recursively remove a Rational from all arguments\n",
      " |      and return that (content) and the new self (primitive). The content\n",
      " |      should always be positive and ``Mul(*foo.as_content_primitive()) == foo``.\n",
      " |      The primitive need not be in canonical form and should try to preserve\n",
      " |      the underlying structure if possible (i.e. expand_mul should not be\n",
      " |      applied to self).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> eq = 2 + 2*x + 2*y*(3 + 3*y)\n",
      " |      \n",
      " |      The as_content_primitive function is recursive and retains structure:\n",
      " |      \n",
      " |      >>> eq.as_content_primitive()\n",
      " |      (2, x + 3*y*(y + 1) + 1)\n",
      " |      \n",
      " |      Integer powers will have Rationals extracted from the base:\n",
      " |      \n",
      " |      >>> ((2 + 6*x)**2).as_content_primitive()\n",
      " |      (4, (3*x + 1)**2)\n",
      " |      >>> ((2 + 6*x)**(2*y)).as_content_primitive()\n",
      " |      (1, (2*(3*x + 1))**(2*y))\n",
      " |      \n",
      " |      Terms may end up joining once their as_content_primitives are added:\n",
      " |      \n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (11, x*(y + 1))\n",
      " |      >>> ((3*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (9, x*(y + 1))\n",
      " |      >>> ((3*(z*(1 + y)) + 2.0*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (1, 6.0*x*(y + 1) + 3*z*(y + 1))\n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (121, x**2*(y + 1)**2)\n",
      " |      >>> ((x*(1 + y) + 0.4*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (1, 4.84*x**2*(y + 1)**2)\n",
      " |      \n",
      " |      Radical content can also be factored out of the primitive:\n",
      " |      \n",
      " |      >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)\n",
      " |      (2, sqrt(2)*(1 + 2*sqrt(5)))\n",
      " |      \n",
      " |      If clear=False (default is True) then content will not be removed\n",
      " |      from an Add if it can be distributed to leave one or more\n",
      " |      terms with integer coefficients.\n",
      " |      \n",
      " |      >>> (x/2 + y).as_content_primitive()\n",
      " |      (1/2, x + 2*y)\n",
      " |      >>> (x/2 + y).as_content_primitive(clear=False)\n",
      " |      (1, x/2 + y)\n",
      " |  \n",
      " |  as_expr(self, *gens)\n",
      " |      Convert a polynomial to a SymPy expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = (x**2 + x*y).as_poly(x, y)\n",
      " |      >>> f.as_expr()\n",
      " |      x**2 + x*y\n",
      " |      \n",
      " |      >>> sin(x).as_expr()\n",
      " |      sin(x)\n",
      " |  \n",
      " |  as_independent(self, *deps, **hint) -> 'tuple[Expr, Expr]'\n",
      " |      A mostly naive separation of a Mul or Add into arguments that are not\n",
      " |      are dependent on deps. To obtain as complete a separation of variables\n",
      " |      as possible, use a separation method first, e.g.:\n",
      " |      \n",
      " |      * separatevars() to change Mul, Add and Pow (including exp) into Mul\n",
      " |      * .expand(mul=True) to change Add or Mul into Add\n",
      " |      * .expand(log=True) to change log expr into an Add\n",
      " |      \n",
      " |      The only non-naive thing that is done here is to respect noncommutative\n",
      " |      ordering of variables and to always return (0, 0) for `self` of zero\n",
      " |      regardless of hints.\n",
      " |      \n",
      " |      For nonzero `self`, the returned tuple (i, d) has the\n",
      " |      following interpretation:\n",
      " |      \n",
      " |      * i will has no variable that appears in deps\n",
      " |      * d will either have terms that contain variables that are in deps, or\n",
      " |        be equal to 0 (when self is an Add) or 1 (when self is a Mul)\n",
      " |      * if self is an Add then self = i + d\n",
      " |      * if self is a Mul then self = i*d\n",
      " |      * otherwise (self, S.One) or (S.One, self) is returned.\n",
      " |      \n",
      " |      To force the expression to be treated as an Add, use the hint as_Add=True\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      -- self is an Add\n",
      " |      \n",
      " |      >>> from sympy import sin, cos, exp\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> (x + x*y).as_independent(x)\n",
      " |      (0, x*y + x)\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x)\n",
      " |      (y + z, 2*x*sin(x) + x)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x, y)\n",
      " |      (z, 2*x*sin(x) + x + y)\n",
      " |      \n",
      " |      -- self is a Mul\n",
      " |      \n",
      " |      >>> (x*sin(x)*cos(y)).as_independent(x)\n",
      " |      (cos(y), x*sin(x))\n",
      " |      \n",
      " |      non-commutative terms cannot always be separated out when self is a Mul\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> n1, n2, n3 = symbols('n1 n2 n3', commutative=False)\n",
      " |      >>> (n1 + n1*n2).as_independent(n2)\n",
      " |      (n1, n1*n2)\n",
      " |      >>> (n2*n1 + n1*n2).as_independent(n2)\n",
      " |      (0, n1*n2 + n2*n1)\n",
      " |      >>> (n1*n2*n3).as_independent(n1)\n",
      " |      (1, n1*n2*n3)\n",
      " |      >>> (n1*n2*n3).as_independent(n2)\n",
      " |      (n1, n2*n3)\n",
      " |      >>> ((x-n1)*(x-y)).as_independent(x)\n",
      " |      (1, (x - y)*(x - n1))\n",
      " |      \n",
      " |      -- self is anything else:\n",
      " |      \n",
      " |      >>> (sin(x)).as_independent(x)\n",
      " |      (1, sin(x))\n",
      " |      >>> (sin(x)).as_independent(y)\n",
      " |      (sin(x), 1)\n",
      " |      >>> exp(x+y).as_independent(x)\n",
      " |      (1, exp(x + y))\n",
      " |      \n",
      " |      -- force self to be treated as an Add:\n",
      " |      \n",
      " |      >>> (3*x).as_independent(x, as_Add=True)\n",
      " |      (0, 3*x)\n",
      " |      \n",
      " |      -- force self to be treated as a Mul:\n",
      " |      \n",
      " |      >>> (3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x + 3)\n",
      " |      >>> (-3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x - 3)\n",
      " |      \n",
      " |      Note how the below differs from the above in making the\n",
      " |      constant on the dep term positive.\n",
      " |      \n",
      " |      >>> (y*(-3+x)).as_independent(x)\n",
      " |      (y, x - 3)\n",
      " |      \n",
      " |      -- use .as_independent() for true independence testing instead\n",
      " |         of .has(). The former considers only symbols in the free\n",
      " |         symbols while the latter considers all symbols\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> I = Integral(x, (x, 1, 2))\n",
      " |      >>> I.has(x)\n",
      " |      True\n",
      " |      >>> x in I.free_symbols\n",
      " |      False\n",
      " |      >>> I.as_independent(x) == (I, 1)\n",
      " |      True\n",
      " |      >>> (I + x).as_independent(x) == (I, x)\n",
      " |      True\n",
      " |      \n",
      " |      Note: when trying to get independent terms, a separation method\n",
      " |      might need to be used first. In this case, it is important to keep\n",
      " |      track of what you send to this routine so you know how to interpret\n",
      " |      the returned values\n",
      " |      \n",
      " |      >>> from sympy import separatevars, log\n",
      " |      >>> separatevars(exp(x+y)).as_independent(x)\n",
      " |      (exp(y), exp(x))\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> separatevars(x + x*y).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).expand(mul=True).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> a, b=symbols('a b', positive=True)\n",
      " |      >>> (log(a*b).expand(log=True)).as_independent(b)\n",
      " |      (log(a), log(b))\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      separatevars\n",
      " |      expand_log\n",
      " |      sympy.core.add.Add.as_two_terms\n",
      " |      sympy.core.mul.Mul.as_two_terms\n",
      " |      as_coeff_mul\n",
      " |  \n",
      " |  as_leading_term(self, *symbols, logx=None, cdir=0)\n",
      " |      Returns the leading (nonzero) term of the series expansion of self.\n",
      " |      \n",
      " |      The _eval_as_leading_term routines are used to do this, and they must\n",
      " |      always return a non-zero value.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + x**2).as_leading_term(x)\n",
      " |      1\n",
      " |      >>> (1/x**2 + x + x**2).as_leading_term(x)\n",
      " |      x**(-2)\n",
      " |  \n",
      " |  as_numer_denom(self)\n",
      " |      Return the numerator and the denominator of an expression.\n",
      " |      \n",
      " |      expression -> a/b -> a, b\n",
      " |      \n",
      " |      This is just a stub that should be defined by\n",
      " |      an object's class methods to get anything else.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      normal: return ``a/b`` instead of ``(a, b)``\n",
      " |  \n",
      " |  as_ordered_factors(self, order=None)\n",
      " |      Return list of ordered factors (if Mul) else [self].\n",
      " |  \n",
      " |  as_ordered_terms(self, order=None, data=False)\n",
      " |      Transform an expression to an ordered list of terms.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, cos\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms()\n",
      " |      [sin(x)**2*cos(x), sin(x)**2, 1]\n",
      " |  \n",
      " |  as_poly(self, *gens, **args)\n",
      " |      Converts ``self`` to a polynomial or returns ``None``.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly())\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly(x, y))\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + sin(y)).as_poly(x, y))\n",
      " |      None\n",
      " |  \n",
      " |  as_powers_dict(self)\n",
      " |      Return self as a dictionary of factors with each factor being\n",
      " |      treated as a power. The keys are the bases of the factors and the\n",
      " |      values, the corresponding exponents. The resulting dictionary should\n",
      " |      be used with caution if the expression is a Mul and contains non-\n",
      " |      commutative factors since the order that they appeared will be lost in\n",
      " |      the dictionary.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      as_ordered_factors: An alternative for noncommutative applications,\n",
      " |                          returning an ordered list of factors.\n",
      " |      args_cnc: Similar to as_ordered_factors, but guarantees separation\n",
      " |                of commutative and noncommutative factors.\n",
      " |  \n",
      " |  as_terms(self)\n",
      " |      Transform an expression to a list of terms.\n",
      " |  \n",
      " |  aseries(self, x=None, n=6, bound=0, hir=False)\n",
      " |      Asymptotic Series expansion of self.\n",
      " |      This is equivalent to ``self.series(x, oo, n)``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      self : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |      \n",
      " |      hir : Boolean\n",
      " |            Set this parameter to be True to produce hierarchical series.\n",
      " |            It stops the recursion at an early level and may provide nicer\n",
      " |            and more useful results.\n",
      " |      \n",
      " |      bound : Value, Integer\n",
      " |              Use the ``bound`` parameter to give limit on rewriting\n",
      " |              coefficients in its normalised form.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, exp\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> e = sin(1/x + exp(-x)) - sin(1/x)\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)\n",
      " |      \n",
      " |      >>> e.aseries(x, n=3, hir=True)\n",
      " |      -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))\n",
      " |      \n",
      " |      >>> e = exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x, bound=3) # doctest: +SKIP\n",
      " |      exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))\n",
      " |      \n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).aseries(x, n=8)\n",
      " |      1/x\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr\n",
      " |          Asymptotic series expansion of the expression.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      This algorithm is directly induced from the limit computational algorithm provided by Gruntz.\n",
      " |      It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first\n",
      " |      to look for the most rapidly varying subexpression w of a given expression f and then expands f\n",
      " |      in a series in w. Then same thing is recursively done on the leading coefficient\n",
      " |      till we get constant coefficients.\n",
      " |      \n",
      " |      If the most rapidly varying subexpression of a given expression f is f itself,\n",
      " |      the algorithm tries to find a normalised representation of the mrv set and rewrites f\n",
      " |      using this normalised representation.\n",
      " |      \n",
      " |      If the expansion contains an order term, it will be either ``O(x ** (-n))`` or ``O(w ** (-n))``\n",
      " |      where ``w`` belongs to the most rapidly varying expression of ``self``.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] Gruntz, Dominik. A new algorithm for computing asymptotic series.\n",
      " |             In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993.\n",
      " |             pp. 239-244.\n",
      " |      .. [2] Gruntz thesis - p90\n",
      " |      .. [3] https://en.wikipedia.org/wiki/Asymptotic_expansion\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      Expr.aseries: See the docstring of this function for complete details of this wrapper.\n",
      " |  \n",
      " |  cancel(self, *gens, **args)\n",
      " |      See the cancel function in sympy.polys\n",
      " |  \n",
      " |  coeff(self, x, n=1, right=False, _first=True)\n",
      " |      Returns the coefficient from the term(s) containing ``x**n``. If ``n``\n",
      " |      is zero then all terms independent of ``x`` will be returned.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      When ``x`` is noncommutative, the coefficient to the left (default) or\n",
      " |      right of ``x`` can be returned. The keyword 'right' is ignored when\n",
      " |      ``x`` is commutative.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      You can select terms that have an explicit negative in front of them:\n",
      " |      \n",
      " |      >>> (-x + 2*y).coeff(-1)\n",
      " |      x\n",
      " |      >>> (x - 2*y).coeff(-1)\n",
      " |      2*y\n",
      " |      \n",
      " |      You can select terms with no Rational coefficient:\n",
      " |      \n",
      " |      >>> (x + 2*y).coeff(1)\n",
      " |      x\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(1)\n",
      " |      0\n",
      " |      \n",
      " |      You can select terms independent of x by making n=0; in this case\n",
      " |      expr.as_independent(x)[0] is returned (and 0 will be returned instead\n",
      " |      of None):\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x, 0)\n",
      " |      3\n",
      " |      >>> eq = ((x + 1)**3).expand() + 1\n",
      " |      >>> eq\n",
      " |      x**3 + 3*x**2 + 3*x + 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 2]\n",
      " |      >>> eq -= 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 0]\n",
      " |      \n",
      " |      You can select terms that have a numerical term in front of them:\n",
      " |      \n",
      " |      >>> (-x - 2*y).coeff(2)\n",
      " |      -y\n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> (x + sqrt(2)*x).coeff(sqrt(2))\n",
      " |      x\n",
      " |      \n",
      " |      The matching is exact:\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x)\n",
      " |      2\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**2)\n",
      " |      4\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**3)\n",
      " |      0\n",
      " |      >>> (z*(x + y)**2).coeff((x + y)**2)\n",
      " |      z\n",
      " |      >>> (z*(x + y)**2).coeff(x + y)\n",
      " |      0\n",
      " |      \n",
      " |      In addition, no factoring is done, so 1 + z*(1 + y) is not obtained\n",
      " |      from the following:\n",
      " |      \n",
      " |      >>> (x + z*(x + x*y)).coeff(x)\n",
      " |      1\n",
      " |      \n",
      " |      If such factoring is desired, factor_terms can be used first:\n",
      " |      \n",
      " |      >>> from sympy import factor_terms\n",
      " |      >>> factor_terms(x + z*(x + x*y)).coeff(x)\n",
      " |      z*(y + 1) + 1\n",
      " |      \n",
      " |      >>> n, m, o = symbols('n m o', commutative=False)\n",
      " |      >>> n.coeff(n)\n",
      " |      1\n",
      " |      >>> (3*n).coeff(n)\n",
      " |      3\n",
      " |      >>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m\n",
      " |      1 + m\n",
      " |      >>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m\n",
      " |      m\n",
      " |      \n",
      " |      If there is more than one possible coefficient 0 is returned:\n",
      " |      \n",
      " |      >>> (n*m + m*n).coeff(n)\n",
      " |      0\n",
      " |      \n",
      " |      If there is only one possible coefficient, it is returned:\n",
      " |      \n",
      " |      >>> (n*m + x*m*n).coeff(m*n)\n",
      " |      x\n",
      " |      >>> (n*m + x*m*n).coeff(m*n, right=1)\n",
      " |      1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_coefficient: separate the expression into a coefficient and factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  collect(self, syms, func=None, evaluate=True, exact=False, distribute_order_term=True)\n",
      " |      See the collect function in sympy.simplify\n",
      " |  \n",
      " |  combsimp(self)\n",
      " |      See the combsimp function in sympy.simplify\n",
      " |  \n",
      " |  compute_leading_term(self, x, logx=None)\n",
      " |      Deprecated function to compute the leading term of a series.\n",
      " |      \n",
      " |      as_leading_term is only allowed for results of .series()\n",
      " |      This is a wrapper to compute a series first.\n",
      " |  \n",
      " |  conjugate(self)\n",
      " |      Returns the complex conjugate of 'self'.\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |      Return True if self has -1 as a leading factor or has\n",
      " |      more literal negative signs than positive signs in a sum,\n",
      " |      otherwise False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = x - y\n",
      " |      >>> {i.could_extract_minus_sign() for i in (e, -e)}\n",
      " |      {False, True}\n",
      " |      \n",
      " |      Though the ``y - x`` is considered like ``-(x - y)``, since it\n",
      " |      is in a product without a leading factor of -1, the result is\n",
      " |      false below:\n",
      " |      \n",
      " |      >>> (x*(y - x)).could_extract_minus_sign()\n",
      " |      False\n",
      " |      \n",
      " |      To put something in canonical form wrt to sign, use `signsimp`:\n",
      " |      \n",
      " |      >>> from sympy import signsimp\n",
      " |      >>> signsimp(x*(y - x))\n",
      " |      -x*(x - y)\n",
      " |      >>> _.could_extract_minus_sign()\n",
      " |      True\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      Wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  diff(self, *symbols, **assumptions)\n",
      " |  \n",
      " |  dir(self, x, cdir)\n",
      " |  \n",
      " |  equals(self, other, failing_expression=False)\n",
      " |      Return True if self == other, False if it does not, or None. If\n",
      " |      failing_expression is True then the expression which did not simplify\n",
      " |      to a 0 will be returned instead of None.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If ``self`` is a Number (or complex number) that is not zero, then\n",
      " |      the result is False.\n",
      " |      \n",
      " |      If ``self`` is a number and has not evaluated to zero, evalf will be\n",
      " |      used to test whether the expression evaluates to zero. If it does so\n",
      " |      and the result has significance (i.e. the precision is either -1, for\n",
      " |      a Rational result, or is greater than 1) then the evalf value will be\n",
      " |      used to return True or False.\n",
      " |  \n",
      " |  expand(self, deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)\n",
      " |      Expand an expression using hints.\n",
      " |      \n",
      " |      See the docstring of the expand() function in sympy.core.function for\n",
      " |      more information.\n",
      " |  \n",
      " |  extract_additively(self, c)\n",
      " |      Return self - c if it's possible to subtract c from self and\n",
      " |      make all matching coefficients move towards zero, else return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = 2*x + 3\n",
      " |      >>> e.extract_additively(x + 1)\n",
      " |      x + 2\n",
      " |      >>> e.extract_additively(3*x)\n",
      " |      >>> e.extract_additively(4)\n",
      " |      >>> (y*(x + 1)).extract_additively(x + 1)\n",
      " |      >>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1)\n",
      " |      (x + 1)*(x + 2*y) + 3\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      extract_multiplicatively\n",
      " |      coeff\n",
      " |      as_coefficient\n",
      " |  \n",
      " |  extract_branch_factor(self, allow_half=False)\n",
      " |      Try to write self as ``exp_polar(2*pi*I*n)*z`` in a nice way.\n",
      " |      Return (z, n).\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, I, pi\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> exp_polar(I*pi).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), 0)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor()\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(-pi*I).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), -1)\n",
      " |      >>> exp_polar(3*pi*I + x).extract_branch_factor()\n",
      " |      (exp_polar(x + I*pi), 1)\n",
      " |      >>> (y*exp_polar(-5*pi*I)*exp_polar(3*pi*I + 2*pi*x)).extract_branch_factor()\n",
      " |      (y*exp_polar(2*pi*x), -1)\n",
      " |      >>> exp_polar(-I*pi/2).extract_branch_factor()\n",
      " |      (exp_polar(-I*pi/2), 0)\n",
      " |      \n",
      " |      If allow_half is True, also extract exp_polar(I*pi):\n",
      " |      \n",
      " |      >>> exp_polar(I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1/2)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(3*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 3/2)\n",
      " |      >>> exp_polar(-I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, -1/2)\n",
      " |  \n",
      " |  extract_multiplicatively(self, c)\n",
      " |      Return None if it's not possible to make self in the form\n",
      " |      c * something in a nice way, i.e. preserving the properties\n",
      " |      of arguments of self.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Rational\n",
      " |      \n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**2 * y)\n",
      " |      x*y**2\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**4 * y)\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(2)\n",
      " |      x\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(3)\n",
      " |      \n",
      " |      >>> (Rational(1, 2)*x).extract_multiplicatively(3)\n",
      " |      x/6\n",
      " |  \n",
      " |  factor(self, *gens, **args)\n",
      " |      See the factor() function in sympy.polys.polytools\n",
      " |  \n",
      " |  fourier_series(self, limits=None)\n",
      " |      Compute fourier sine/cosine series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fourier_series` in sympy.series.fourier\n",
      " |      for more information.\n",
      " |  \n",
      " |  fps(self, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)\n",
      " |      Compute formal power power series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fps` function in sympy.series.formal for\n",
      " |      more information.\n",
      " |  \n",
      " |  gammasimp(self)\n",
      " |      See the gammasimp function in sympy.simplify\n",
      " |  \n",
      " |  getO(self)\n",
      " |      Returns the additive O(..) symbol if there is one, else None.\n",
      " |  \n",
      " |  getn(self)\n",
      " |      Returns the order of the expression.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      The order is determined either from the O(...) term. If there\n",
      " |      is no O(...) term, it returns None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import O\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + O(x**2)).getn()\n",
      " |      2\n",
      " |      >>> (1 + x).getn()\n",
      " |  \n",
      " |  integrate(self, *args, **kwargs)\n",
      " |      See the integrate function in sympy.integrals\n",
      " |  \n",
      " |  invert(self, g, *gens, **args)\n",
      " |      Return the multiplicative inverse of ``self`` mod ``g``\n",
      " |      where ``self`` (and ``g``) may be symbolic expressions).\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      sympy.core.numbers.mod_inverse, sympy.polys.polytools.invert\n",
      " |  \n",
      " |  is_algebraic_expr(self, *syms)\n",
      " |      This tests whether a given expression is algebraic or not, in the\n",
      " |      given symbols, syms. When syms is not given, all free symbols\n",
      " |      will be used. The rational function does not have to be in expanded\n",
      " |      or in any kind of canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"algebraic\n",
      " |      expressions\" with symbolic exponents. This is a simple extension to the\n",
      " |      is_rational_function, including rational exponentiation.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sqrt\n",
      " |      >>> x = Symbol('x', real=True)\n",
      " |      >>> sqrt(1 + x).is_rational_function()\n",
      " |      False\n",
      " |      >>> sqrt(1 + x).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be an algebraic\n",
      " |      expression to become one.\n",
      " |      \n",
      " |      >>> from sympy import exp, factor\n",
      " |      >>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1)\n",
      " |      >>> a.is_algebraic_expr(x)\n",
      " |      False\n",
      " |      >>> factor(a).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      is_rational_function\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Algebraic_expression\n",
      " |  \n",
      " |  is_meromorphic(self, x, a)\n",
      " |      This tests whether an expression is meromorphic as\n",
      " |      a function of the given symbol ``x`` at the point ``a``.\n",
      " |      \n",
      " |      This method is intended as a quick test that will return\n",
      " |      None if no decision can be made without simplification or\n",
      " |      more detailed analysis.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import zoo, log, sin, sqrt\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = 1/x**2 + 1 - 2*x**3\n",
      " |      >>> f.is_meromorphic(x, 0)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      >>> g = x**log(3)\n",
      " |      >>> g.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> g.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> g.is_meromorphic(x, zoo)\n",
      " |      False\n",
      " |      \n",
      " |      >>> h = sin(1/x)*x**2\n",
      " |      >>> h.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> h.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> h.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      Multivalued functions are considered meromorphic when their\n",
      " |      branches are meromorphic. Thus most functions are meromorphic\n",
      " |      everywhere except at essential singularities and branch points.\n",
      " |      In particular, they will be meromorphic also on branch cuts\n",
      " |      except at their endpoints.\n",
      " |      \n",
      " |      >>> log(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> log(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> sqrt(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> sqrt(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |  \n",
      " |  is_polynomial(self, *syms)\n",
      " |      Return True if self is a polynomial in syms and False otherwise.\n",
      " |      \n",
      " |      This checks if self is an exact polynomial in syms.  This function\n",
      " |      returns False for expressions that are \"polynomials\" with symbolic\n",
      " |      exponents.  Thus, you should be able to apply polynomial algorithms to\n",
      " |      expressions for which this returns True, and Poly(expr, \\*syms) should\n",
      " |      work if and only if expr.is_polynomial(\\*syms) returns True. The\n",
      " |      polynomial does not have to be in expanded form.  If no symbols are\n",
      " |      given, all free symbols in the expression will be used.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', polynomial=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, Function\n",
      " |      >>> x = Symbol('x')\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial(x)\n",
      " |      True\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial()\n",
      " |      True\n",
      " |      >>> (2**x + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (2**x + 1).is_polynomial(2**x)\n",
      " |      True\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (f(x) + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (f(x) + 1).is_polynomial(f(x))\n",
      " |      True\n",
      " |      >>> (1/f(x) + 1).is_polynomial(f(x))\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', nonnegative=True, integer=True)\n",
      " |      >>> (x**n + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a polynomial to\n",
      " |      become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor, cancel\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)\n",
      " |      >>> a.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      y + 1\n",
      " |      >>> factor(a).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      >>> b = (y**2 + 2*y + 1)/(y + 1)\n",
      " |      >>> b.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> cancel(b)\n",
      " |      y + 1\n",
      " |      >>> cancel(b).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also .is_rational_function()\n",
      " |  \n",
      " |  is_rational_function(self, *syms)\n",
      " |      Test whether function is a ratio of two polynomials in the given\n",
      " |      symbols, syms. When syms is not given, all free symbols will be used.\n",
      " |      The rational function does not have to be in expanded or in any kind of\n",
      " |      canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"rational\n",
      " |      functions\" with symbolic exponents.  Thus, you should be able to call\n",
      " |      .as_numer_denom() and apply polynomial algorithms to the result for\n",
      " |      expressions for which this returns True.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', rational_function=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> (x/y).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x**2).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x/sin(y)).is_rational_function(y)\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', integer=True)\n",
      " |      >>> (x**n + 1).is_rational_function(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a rational function\n",
      " |      to become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)/y\n",
      " |      >>> a.is_rational_function(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      (y + 1)/y\n",
      " |      >>> factor(a).is_rational_function(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also is_algebraic_expr().\n",
      " |  \n",
      " |  leadterm(self, x, logx=None, cdir=0)\n",
      " |      Returns the leading term a*x**b as a tuple (a, b).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1+x+x**2).leadterm(x)\n",
      " |      (1, 0)\n",
      " |      >>> (1/x**2+x+x**2).leadterm(x)\n",
      " |      (1, -2)\n",
      " |  \n",
      " |  limit(self, x, xlim, dir='+')\n",
      " |      Compute limit x->xlim.\n",
      " |  \n",
      " |  lseries(self, x=None, x0=0, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper for series yielding an iterator of the terms of the series.\n",
      " |      \n",
      " |      Note: an infinite series will yield an infinite iterator. The following,\n",
      " |      for exaxmple, will never terminate. It will just keep printing terms\n",
      " |      of the sin(x) series::\n",
      " |      \n",
      " |        for term in sin(x).lseries(x):\n",
      " |            print term\n",
      " |      \n",
      " |      The advantage of lseries() over nseries() is that many times you are\n",
      " |      just interested in the next term in the series (i.e. the first term for\n",
      " |      example), but you do not know how many you should ask for in nseries()\n",
      " |      using the \"n\" parameter.\n",
      " |      \n",
      " |      See also nseries().\n",
      " |  \n",
      " |  normal(self)\n",
      " |      Return the expression as a fraction.\n",
      " |      \n",
      " |      expression -> a/b\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_numer_denom: return ``(a, b)`` instead of ``a/b``\n",
      " |  \n",
      " |  nseries(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper to _eval_nseries if assumptions allow, else to series.\n",
      " |      \n",
      " |      If x is given, x0 is 0, dir='+', and self has x, then _eval_nseries is\n",
      " |      called. This calculates \"n\" terms in the innermost expressions and\n",
      " |      then builds up the final series just by \"cross-multiplying\" everything\n",
      " |      out.\n",
      " |      \n",
      " |      The optional ``logx`` parameter can be used to replace any log(x) in the\n",
      " |      returned series with a symbolic value to avoid evaluating log(x) at 0. A\n",
      " |      symbol to use in place of log(x) should be provided.\n",
      " |      \n",
      " |      Advantage -- it's fast, because we do not have to determine how many\n",
      " |      terms we need to calculate in advance.\n",
      " |      \n",
      " |      Disadvantage -- you may end up with less terms than you may have\n",
      " |      expected, but the O(x**n) term appended will always be correct and\n",
      " |      so the result, though perhaps shorter, will also be correct.\n",
      " |      \n",
      " |      If any of those assumptions is not met, this is treated like a\n",
      " |      wrapper to series which will try harder to return the correct\n",
      " |      number of terms.\n",
      " |      \n",
      " |      See also lseries().\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, log, Symbol\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> sin(x).nseries(x, 0, 6)\n",
      " |      x - x**3/6 + x**5/120 + O(x**6)\n",
      " |      >>> log(x+1).nseries(x, 0, 5)\n",
      " |      x - x**2/2 + x**3/3 - x**4/4 + O(x**5)\n",
      " |      \n",
      " |      Handling of the ``logx`` parameter --- in the following example the\n",
      " |      expansion fails since ``sin`` does not have an asymptotic expansion\n",
      " |      at -oo (the limit of log(x) as x approaches 0):\n",
      " |      \n",
      " |      >>> e = sin(log(x))\n",
      " |      >>> e.nseries(x, 0, 6)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      PoleError: ...\n",
      " |      ...\n",
      " |      >>> logx = Symbol('logx')\n",
      " |      >>> e.nseries(x, 0, 6, logx=logx)\n",
      " |      sin(logx)\n",
      " |      \n",
      " |      In the following example, the expansion works but only returns self\n",
      " |      unless the ``logx`` parameter is used:\n",
      " |      \n",
      " |      >>> e = x**y\n",
      " |      >>> e.nseries(x, 0, 2)\n",
      " |      x**y\n",
      " |      >>> e.nseries(x, 0, 2, logx=logx)\n",
      " |      exp(logx*y)\n",
      " |  \n",
      " |  nsimplify(self, constants=(), tolerance=None, full=False)\n",
      " |      See the nsimplify function in sympy.simplify\n",
      " |  \n",
      " |  powsimp(self, *args, **kwargs)\n",
      " |      See the powsimp function in sympy.simplify\n",
      " |  \n",
      " |  primitive(self)\n",
      " |      Return the positive Rational that can be extracted non-recursively\n",
      " |      from every term of self (i.e., self is treated like an Add). This is\n",
      " |      like the as_coeff_Mul() method but primitive always extracts a positive\n",
      " |      Rational (never a negative or a Float).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (3*(x + 1)**2).primitive()\n",
      " |      (3, (x + 1)**2)\n",
      " |      >>> a = (6*x + 2); a.primitive()\n",
      " |      (2, 3*x + 1)\n",
      " |      >>> b = (x/2 + 3); b.primitive()\n",
      " |      (1/2, x + 6)\n",
      " |      >>> (a*b).primitive() == (1, a*b)\n",
      " |      True\n",
      " |  \n",
      " |  radsimp(self, **kwargs)\n",
      " |      See the radsimp function in sympy.simplify\n",
      " |  \n",
      " |  ratsimp(self)\n",
      " |      See the ratsimp function in sympy.simplify\n",
      " |  \n",
      " |  removeO(self)\n",
      " |      Removes the additive O(..) symbol if there is one\n",
      " |  \n",
      " |  round(self, n=None)\n",
      " |      Return x rounded to the given decimal place.\n",
      " |      \n",
      " |      If a complex number would results, apply round to the real\n",
      " |      and imaginary components of the number.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, E, I, S, Number\n",
      " |      >>> pi.round()\n",
      " |      3\n",
      " |      >>> pi.round(2)\n",
      " |      3.14\n",
      " |      >>> (2*pi + E*I).round()\n",
      " |      6 + 3*I\n",
      " |      \n",
      " |      The round method has a chopping effect:\n",
      " |      \n",
      " |      >>> (2*pi + I/10).round()\n",
      " |      6\n",
      " |      >>> (pi/10 + 2*I).round()\n",
      " |      2*I\n",
      " |      >>> (pi/10 + E*I).round(2)\n",
      " |      0.31 + 2.72*I\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      The Python ``round`` function uses the SymPy ``round`` method so it\n",
      " |      will always return a SymPy number (not a Python float or int):\n",
      " |      \n",
      " |      >>> isinstance(round(S(123), -2), Number)\n",
      " |      True\n",
      " |  \n",
      " |  separate(self, deep=False, force=False)\n",
      " |      See the separate function in sympy.simplify\n",
      " |  \n",
      " |  series(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Series expansion of \"self\" around ``x = x0`` yielding either terms of\n",
      " |      the series one by one (the lazy series given when n=None), else\n",
      " |      all the terms at once when n != None.\n",
      " |      \n",
      " |      Returns the series expansion of \"self\" around the point ``x = x0``\n",
      " |      with respect to ``x`` up to ``O((x - x0)**n, x, x0)`` (default n is 6).\n",
      " |      \n",
      " |      If ``x=None`` and ``self`` is univariate, the univariate symbol will\n",
      " |      be supplied, otherwise an error will be raised.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      expr : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      x0 : Value\n",
      " |           The value around which ``x`` is calculated. Can be any value\n",
      " |           from ``-oo`` to ``oo``.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |      \n",
      " |      dir : String, optional\n",
      " |            The series-expansion can be bi-directional. If ``dir=\"+\"``,\n",
      " |            then (x->x0+). If ``dir=\"-\", then (x->x0-). For infinite\n",
      " |            ``x0`` (``oo`` or ``-oo``), the ``dir`` argument is determined\n",
      " |            from the direction of the infinity (i.e., ``dir=\"-\"`` for\n",
      " |            ``oo``).\n",
      " |      \n",
      " |      logx : optional\n",
      " |             It is used to replace any log(x) in the returned series with a\n",
      " |             symbolic value rather than evaluating the actual value.\n",
      " |      \n",
      " |      cdir : optional\n",
      " |             It stands for complex direction, and indicates the direction\n",
      " |             from which the expansion needs to be evaluated.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, exp, tan\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> cos(x).series()\n",
      " |      1 - x**2/2 + x**4/24 + O(x**6)\n",
      " |      >>> cos(x).series(n=4)\n",
      " |      1 - x**2/2 + O(x**4)\n",
      " |      >>> cos(x).series(x, x0=1, n=2)\n",
      " |      cos(1) - (x - 1)*sin(1) + O((x - 1)**2, (x, 1))\n",
      " |      >>> e = cos(x + exp(y))\n",
      " |      >>> e.series(y, n=2)\n",
      " |      cos(x + 1) - y*sin(x + 1) + O(y**2)\n",
      " |      >>> e.series(x, n=2)\n",
      " |      cos(exp(y)) - x*sin(exp(y)) + O(x**2)\n",
      " |      \n",
      " |      If ``n=None`` then a generator of the series terms will be returned.\n",
      " |      \n",
      " |      >>> term=cos(x).series(n=None)\n",
      " |      >>> [next(term) for i in range(2)]\n",
      " |      [1, -x**2/2]\n",
      " |      \n",
      " |      For ``dir=+`` (default) the series is calculated from the right and\n",
      " |      for ``dir=-`` the series from the left. For smooth functions this\n",
      " |      flag will not alter the results.\n",
      " |      \n",
      " |      >>> abs(x).series(dir=\"+\")\n",
      " |      x\n",
      " |      >>> abs(x).series(dir=\"-\")\n",
      " |      -x\n",
      " |      >>> f = tan(x)\n",
      " |      >>> f.series(x, 2, 6, \"+\")\n",
      " |      tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +\n",
      " |      (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +\n",
      " |      5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +\n",
      " |      2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))\n",
      " |      \n",
      " |      >>> f.series(x, 2, 3, \"-\")\n",
      " |      tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))\n",
      " |      + O((x - 2)**3, (x, 2))\n",
      " |      \n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).series(x, n=8)\n",
      " |      1/x\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr : Expression\n",
      " |          Series expansion of the expression about x0\n",
      " |      \n",
      " |      Raises\n",
      " |      ======\n",
      " |      \n",
      " |      TypeError\n",
      " |          If \"n\" and \"x0\" are infinity objects\n",
      " |      \n",
      " |      PoleError\n",
      " |          If \"x0\" is an infinity object\n",
      " |  \n",
      " |  taylor_term(self, n, x, *previous_terms)\n",
      " |      General method for the taylor term.\n",
      " |      \n",
      " |      This method is slow, because it differentiates n-times. Subclasses can\n",
      " |      redefine it to make it faster by using the \"previous_terms\".\n",
      " |  \n",
      " |  together(self, *args, **kwargs)\n",
      " |      See the together function in sympy.polys\n",
      " |  \n",
      " |  transpose(self)\n",
      " |  \n",
      " |  trigsimp(self, **args)\n",
      " |      See the trigsimp function in sympy.simplify\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  is_scalar = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.logic.boolalg.Boolean:\n",
      " |  \n",
      " |  __and__(self, other)\n",
      " |  \n",
      " |  __invert__(self)\n",
      " |      Overloading for ~\n",
      " |  \n",
      " |  __lshift__(self, other)\n",
      " |  \n",
      " |  __or__(self, other)\n",
      " |      Return self|value.\n",
      " |  \n",
      " |  __rand__ = __and__(self, other)\n",
      " |  \n",
      " |  __rlshift__ = __rshift__(self, other)\n",
      " |  \n",
      " |  __ror__ = __or__(self, other)\n",
      " |  \n",
      " |  __rrshift__ = __lshift__(self, other)\n",
      " |  \n",
      " |  __rshift__(self, other)\n",
      " |  \n",
      " |  __rxor__ = __xor__(self, other)\n",
      " |  \n",
      " |  __xor__(self, other)\n",
      " |  \n",
      " |  to_nnf(self, simplify=True)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from https://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __hash__(self) -> 'int'\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      Return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  has_xfree(self, s: 'set[Basic]')\n",
      " |      Return True if self has any of the patterns in s as a\n",
      " |      free argument, else False. This is like `Basic.has_free`\n",
      " |      but this will only report exact argument matches.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> f(x).has_xfree({f})\n",
      " |      False\n",
      " |      >>> f(x).has_xfree({f(x)})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x + 1})\n",
      " |      True\n",
      " |      >>> f(x + y + 1).has_xfree({x + 1})\n",
      " |      False\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : Expr\n",
      " |          A *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __init_subclass__() from builtins.type\n",
      " |      This method is called when a class is subclassed.\n",
      " |      \n",
      " |      The default implementation does nothing. It may be\n",
      " |      overridden to extend subclasses.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from builtins.type\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Function = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Symbol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "frum=Frustum(3,RegularPolygon((0,0),3,3),2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\operatorname{Point3D}\\left(2, 0, 2\\right), \\  \\operatorname{Point3D}\\left(-1, \\sqrt{3}, 2\\right), \\  \\operatorname{Point3D}\\left(-1, - \\sqrt{3}, 2\\right), \\  \\operatorname{Point3D}\\left(3, 0, 0\\right), \\  \\operatorname{Point3D}\\left(- \\frac{3}{2}, \\frac{3 \\sqrt{3}}{2}, 0\\right), \\  \\operatorname{Point3D}\\left(- \\frac{3}{2}, - \\frac{3 \\sqrt{3}}{2}, 0\\right)\\right)$"
      ],
      "text/plain": [
       "(Point3D(2, 0, 2), Point3D(-1, sqrt(3), 2), Point3D(-1, -sqrt(3), 2), Point3D(3, 0, 0), Point3D(-3/2, 3*sqrt(3)/2, 0), Point3D(-3/2, -3*sqrt(3)/2, 0))"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frum.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(x-1)*(x-2)*(x-3)*(x-4)+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(x - 4\\right) \\left(x - 3\\right) \\left(x - 2\\right) \\left(x - 1\\right) + 1$"
      ],
      "text/plain": [
       "(x - 4)*(x - 3)*(x - 2)*(x - 1) + 1"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(x^{2} - 5 x + 5\\right)^{2}$"
      ],
      "text/plain": [
       "(x**2 - 5*x + 5)**2"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type({3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport basic_package.vec\n",
    "from basic_package.vec import Vec\n",
    "a=Vec(\"a\",[12,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b$"
      ],
      "text/plain": [
       "b"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vec(\"b\",[1,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import Matrix\n",
    "\n",
    "A = Matrix([[1, 2], [3, 4]])\n",
    "# 将矩阵 A 中的每个元素加 1\n",
    "B = A.applyfunc(lambda x: x + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}2 & 3\\\\4 & 5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡2  3⎤\n",
       "⎢    ⎥\n",
       "⎣4  5⎦"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Hi():\n",
    "    def __repr__(self):\n",
    "        return \"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.5"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "120/16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "40/16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=MatrixSymbol(\"A\",2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=MatrixSymbol(\"B\",2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date, datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=datetime.now()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=datetime.now()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 装饰器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import wraps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_times(func):\n",
    "    @wraps(func)\n",
    "    def wrapper(*args,**kwargs):\n",
    "        \"\"\"\n",
    "        The decorator.\n",
    "        \"\"\"\n",
    "        a=datetime.now()\n",
    "        result=func(*args,**kwargs)\n",
    "        b=datetime.now()\n",
    "        print(b-a)\n",
    "        return result\n",
    "    return wrapper\n",
    "\n",
    "class Test():\n",
    "    def __init__(self):\n",
    "        self.name=\"huang\"\n",
    "\n",
    "    @get_times\n",
    "    def find(self,n):\n",
    "        \"\"\"\n",
    "        find the primes.\n",
    "        \"\"\"\n",
    "        answer=[]\n",
    "        for i in range(n):\n",
    "            if(is_mersenne_prime(i)):\n",
    "                answer.append(i)\n",
    "        return answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=Test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0:00:00.000322\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[3, 7]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.find(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'find'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.find.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n        find the primes.\\n        '"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.find.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 生成器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recircle(init):\n",
    "    while True:\n",
    "        yield 1-1/init\n",
    "        init=1-1/init"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n",
      "2\n",
      "1/2\n",
      "-1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "r=recircle(S(1)/2)\n",
    "for i in range(5):\n",
    "    print(next(r))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 迭代器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "class iter_circle():\n",
    "    def __init__(self,value):\n",
    "        self.value=value\n",
    "    \n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "        self.value=1-1/self.value\n",
    "        return self.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2\n",
      "3/2\n",
      "1/3\n",
      "-2\n",
      "3/2\n",
      "1/3\n",
      "-2\n",
      "3/2\n",
      "1/3\n",
      "-2\n",
      "3/2\n",
      "1/3\n",
      "-2\n",
      "3/2\n",
      "1/3\n",
      "-2\n"
     ]
    }
   ],
   "source": [
    "count=0\n",
    "for i in iter_circle(S(1)/3):\n",
    "    print(i)\n",
    "    count+=1\n",
    "    if(count>15):\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ctypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ctypes import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<CDLL 'libc.so.6', handle 7a083411e6d0 at 0x7a07ebe31eb0>"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cdll.LoadLibrary(\"libc.so.6\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "libc=CDLL(\"libc.so.6\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1025202362"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "libc.rand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "libc.printf(b\"Hello, %s\\n\", b\"World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thread 1: 1\n",
      "Thread 2: 6\n",
      "Thread 2: 7\n",
      "Thread 1: 2\n",
      "Thread 1: 3\n",
      "Thread 2: 8\n",
      "Thread 1: 4\n",
      "Thread 2: 9\n",
      "Thread 1: 5\n",
      "Thread 2: 10\n",
      "所有线程已完成执行。\n"
     ]
    }
   ],
   "source": [
    "import threading\n",
    "import time\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thread 1: 1\n",
      "Thread 2: 6\n",
      "Thread 1: 2\n",
      "Thread 2: 7\n",
      "Thread 1: 3\n",
      "Thread 2: 8\n",
      "Thread 1: 4\n",
      "Thread 2: 9\n",
      "Thread 1: 5\n",
      "Thread 2: 10\n",
      "所有线程已完成执行。\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 定义线程要执行的函数\n",
    "def print_numbers(name, start, end):\n",
    "    for i in range(start, end):\n",
    "        print(f\"Thread {name}: {i}\")\n",
    "        time.sleep(0.5)  # 暂停0.5秒，以观察线程的并发执行\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# 创建线程\n",
    "thread1 = threading.Thread(target=print_numbers, args=(1, 1, 6))\n",
    "thread2 = threading.Thread(target=print_numbers, args=(2, 6, 11))\n",
    "\n",
    "# 启动线程\n",
    "thread1.start()\n",
    "thread2.start()\n",
    "\n",
    "# 等待所有线程完成\n",
    "thread1.join()\n",
    "thread2.join()\n",
    "\n",
    "print(\"所有线程已完成执行。\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=5\n",
    "def add(value):\n",
    "    global x\n",
    "    x+=value\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "del x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "bn=n-1/S(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(-1\\right)^{n} n \\left(n + 1\\right)}{2} - \\frac{\\left(-1\\right)^{n + 1}}{8} - \\frac{2 \\left(-1\\right)^{n} n + \\left(-1\\right)^{n} - 1}{4} - \\frac{1}{8}$"
      ],
      "text/plain": [
       "(-1)**n*n*(n + 1)/2 - (-1)**(n + 1)/8 - (2*(-1)**n*n + (-1)**n - 1)/4 - 1/8"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation((-1)**n*bn**2,(n,1,n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(-1\\right)^{n} n^{2}}{2} - \\frac{\\left(-1\\right)^{n}}{8} + \\frac{1}{8}$"
      ],
      "text/plain": [
       "(-1)**n*n**2/2 - (-1)**n/8 + 1/8"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\left(-1\\right)^{2 n} n^{2} - \\frac{\\left(-1\\right)^{2 n}}{8} + \\frac{1}{8}$"
      ],
      "text/plain": [
       "2*(-1)**(2*n)*n**2 - (-1)**(2*n)/8 + 1/8"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.subs(n,2*n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\left(-1\\right)^{2 n} n^{2} - \\frac{\\left(-1\\right)^{2 n}}{8} + \\frac{1}{8}$"
      ],
      "text/plain": [
       "2*(-1)**(2*n)*n**2 - (-1)**(2*n)/8 + 1/8"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=symbols(\"n\",integer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n in Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "an=(-2)**(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-2\\right)^{n - 1}$"
      ],
      "text/plain": [
       "(-2)**(n - 1)"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "an"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{3 \\left(-2\\right)^{n} n + \\left(-2\\right)^{n} - 1}{9}$"
      ],
      "text/plain": [
       "-(3*(-2)**n*n + (-2)**n - 1)/9"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation(n*an,(n,1,n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 2^{- n} \\left(- 2 \\cdot 2^{n} + n + 2\\right)$"
      ],
      "text/plain": [
       "-(-2*2**n + n + 2)/2**n"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation(n/2**n,(n,1,n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2^{- n} \\left(2^{n + 1} - n - 2\\right)$"
      ],
      "text/plain": [
       "(2**(n + 1) - n - 2)/2**n"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 - 2^{- n} n - 2 \\cdot 2^{- n}$"
      ],
      "text/plain": [
       "2 - n/2**n - 2/2**n"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.matrices.expressions.matexpr.MatrixSymbol"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left|{A}\\right|$"
      ],
      "text/plain": [
       "Determinant(A)"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "det(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x+y\n"
     ]
    }
   ],
   "source": [
    "from sympy import symbols, Add\n",
    "from sympy.printing.str import StrPrinter\n",
    "\n",
    "x, y = symbols('x y')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import Mul"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.printing.printer import Printer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class CustomPrinter(Printer):\n",
    "    def _print_Mul(self, expr):\n",
    "        return '*|*'.join(self._print(arg) for arg in expr.args)\n",
    "\n",
    "    def get_postprocessor(self, expr):\n",
    "        def postprocess(s):\n",
    "            # 简单的后处理器示例：在字符串前后添加括号\n",
    "            return f\"({s}*{s})\"\n",
    "        return postprocess\n",
    "\n",
    "printer = CustomPrinter()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr = Mul(x, y, evaluate=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'x*|*y'"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "printer.doprint(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x y$"
      ],
      "text/plain": [
       "x*y"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x + y$"
      ],
      "text/plain": [
       "x + y"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x+y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=x+y*cos(t)/(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x + \\frac{y \\cos{\\left(t \\right)}}{2}$"
      ],
      "text/plain": [
       "x + y*cos(t)/2"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=y*sin(t)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{y \\sin{\\left(t \\right)}}{2}$"
      ],
      "text/plain": [
       "y*sin(t)/2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt=a**2+b**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{y^{2} \\sin^{2}{\\left(t \\right)}}{4} + \\left(x + \\frac{y \\cos{\\left(t \\right)}}{2}\\right)^{2}$"
      ],
      "text/plain": [
       "y**2*sin(t)**2/4 + (x + y*cos(t)/2)**2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} + x y \\cos{\\left(t \\right)} + \\frac{y^{2}}{4}$"
      ],
      "text/plain": [
       "x**2 + x*y*cos(t) + y**2/4"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "r=symbols(\"r\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(r^{2} - x^{2}\\right) \\sin^{2}{\\left(t \\right)}}{4} + \\left(x + \\frac{\\sqrt{r^{2} - x^{2}} \\cos{\\left(t \\right)}}{2}\\right)^{2}$"
      ],
      "text/plain": [
       "(r**2 - x**2)*sin(t)**2/4 + (x + sqrt(r**2 - x**2)*cos(t)/2)**2"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt.subs(y,sqrt(r**2-x**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{r^{2}}{4} + \\frac{3 x^{2}}{4} + x \\sqrt{r^{2} - x^{2}} \\cos{\\left(t \\right)}$"
      ],
      "text/plain": [
       "r**2/4 + 3*x**2/4 + x*sqrt(r**2 - x**2)*cos(t)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "data={r:1,t:pi/4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{3 x^{2}}{4} + \\frac{\\sqrt{2} x \\sqrt{1 - x^{2}}}{2} + \\frac{1}{4}$"
      ],
      "text/plain": [
       "3*x**2/4 + sqrt(2)*x*sqrt(1 - x**2)/2 + 1/4"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check.subs(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\frac{1}{4}, \\frac{\\sqrt{2} \\sqrt{\\frac{1}{2} - \\frac{3 \\sqrt{17}}{34}} \\sqrt{\\frac{3 \\sqrt{17}}{34} + \\frac{1}{2}}}{2} + \\frac{9 \\sqrt{17}}{136} + \\frac{5}{8}\\right]$"
      ],
      "text/plain": [
       "Interval(1/4, sqrt(2)*sqrt(1/2 - 3*sqrt(17)/34)*sqrt(3*sqrt(17)/34 + 1/2)/2 + 9*sqrt(17)/136 + 5/8)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_range(_,x,Interval(0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{17}}{8} + \\frac{5}{8}$"
      ],
      "text/plain": [
       "sqrt(17)/8 + 5/8"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_.sup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 核心能力 核心技法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "chi=ChiSquaredTest(Matrix([[40,60],[10,90]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 24$"
      ],
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chi.chi_squared_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 6.63489660102121$"
      ],
      "text/plain": [
       "6.63489660102121"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chi_squared_of_error_probability(0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class binomial in module sympy.functions.combinatorial.factorials:\n",
      "\n",
      "class binomial(CombinatorialFunction)\n",
      " |  binomial(n, k)\n",
      " |\n",
      " |  Implementation of the binomial coefficient. It can be defined\n",
      " |  in two ways depending on its desired interpretation:\n",
      " |\n",
      " |  .. math:: \\binom{n}{k} = \\frac{n!}{k!(n-k)!}\\ \\text{or}\\\n",
      " |              \\binom{n}{k} = \\frac{(n)_k}{k!}\n",
      " |\n",
      " |  First, in a strict combinatorial sense it defines the\n",
      " |  number of ways we can choose `k` elements from a set of\n",
      " |  `n` elements. In this case both arguments are nonnegative\n",
      " |  integers and binomial is computed using an efficient\n",
      " |  algorithm based on prime factorization.\n",
      " |\n",
      " |  The other definition is generalization for arbitrary `n`,\n",
      " |  however `k` must also be nonnegative. This case is very\n",
      " |  useful when evaluating summations.\n",
      " |\n",
      " |  For the sake of convenience, for negative integer `k` this function\n",
      " |  will return zero no matter the other argument.\n",
      " |\n",
      " |  To expand the binomial when `n` is a symbol, use either\n",
      " |  ``expand_func()`` or ``expand(func=True)``. The former will keep\n",
      " |  the polynomial in factored form while the latter will expand the\n",
      " |  polynomial itself. See examples for details.\n",
      " |\n",
      " |  Examples\n",
      " |  ========\n",
      " |\n",
      " |  >>> from sympy import Symbol, Rational, binomial, expand_func\n",
      " |  >>> n = Symbol('n', integer=True, positive=True)\n",
      " |\n",
      " |  >>> binomial(15, 8)\n",
      " |  6435\n",
      " |\n",
      " |  >>> binomial(n, -1)\n",
      " |  0\n",
      " |\n",
      " |  Rows of Pascal's triangle can be generated with the binomial function:\n",
      " |\n",
      " |  >>> for N in range(8):\n",
      " |  ...     print([binomial(N, i) for i in range(N + 1)])\n",
      " |  ...\n",
      " |  [1]\n",
      " |  [1, 1]\n",
      " |  [1, 2, 1]\n",
      " |  [1, 3, 3, 1]\n",
      " |  [1, 4, 6, 4, 1]\n",
      " |  [1, 5, 10, 10, 5, 1]\n",
      " |  [1, 6, 15, 20, 15, 6, 1]\n",
      " |  [1, 7, 21, 35, 35, 21, 7, 1]\n",
      " |\n",
      " |  As can a given diagonal, e.g. the 4th diagonal:\n",
      " |\n",
      " |  >>> N = -4\n",
      " |  >>> [binomial(N, i) for i in range(1 - N)]\n",
      " |  [1, -4, 10, -20, 35]\n",
      " |\n",
      " |  >>> binomial(Rational(5, 4), 3)\n",
      " |  -5/128\n",
      " |  >>> binomial(Rational(-5, 4), 3)\n",
      " |  -195/128\n",
      " |\n",
      " |  >>> binomial(n, 3)\n",
      " |  binomial(n, 3)\n",
      " |\n",
      " |  >>> binomial(n, 3).expand(func=True)\n",
      " |  n**3/6 - n**2/2 + n/3\n",
      " |\n",
      " |  >>> expand_func(binomial(n, 3))\n",
      " |  n*(n - 2)*(n - 1)/6\n",
      " |\n",
      " |  References\n",
      " |  ==========\n",
      " |\n",
      " |  .. [1] https://www.johndcook.com/blog/binomial_coefficients/\n",
      " |\n",
      " |  Method resolution order:\n",
      " |      binomial\n",
      " |      CombinatorialFunction\n",
      " |      sympy.core.function.Function\n",
      " |      sympy.core.function.Application\n",
      " |      sympy.core.expr.Expr\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |\n",
      " |  Methods defined here:\n",
      " |\n",
      " |  fdiff(self, argindex=1)\n",
      " |      Returns the first derivative of the function.\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |\n",
      " |  eval(n, k)\n",
      " |      Returns a canonical form of cls applied to arguments args.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      The ``eval()`` method is called when the class ``cls`` is about to be\n",
      " |      instantiated and it should return either some simplified instance\n",
      " |      (possible of some other class), or if the class ``cls`` should be\n",
      " |      unmodified, return None.\n",
      " |\n",
      " |      Examples of ``eval()`` for the function \"sign\"\n",
      " |\n",
      " |      .. code-block:: python\n",
      " |\n",
      " |          @classmethod\n",
      " |          def eval(cls, arg):\n",
      " |              if arg is S.NaN:\n",
      " |                  return S.NaN\n",
      " |              if arg.is_zero: return S.Zero\n",
      " |              if arg.is_positive: return S.One\n",
      " |              if arg.is_negative: return S.NegativeOne\n",
      " |              if isinstance(arg, Mul):\n",
      " |                  coeff, terms = arg.as_coeff_Mul(rational=True)\n",
      " |                  if coeff is not S.One:\n",
      " |                      return cls(coeff) * cls(terms)\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |\n",
      " |  __annotations__ = {}\n",
      " |\n",
      " |  default_assumptions = {}\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.function.Function:\n",
      " |\n",
      " |  as_base_exp(self)\n",
      " |      Returns the method as the 2-tuple (base, exponent).\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.function.Function:\n",
      " |\n",
      " |  class_key()\n",
      " |      Nice order of classes.\n",
      " |\n",
      " |  is_singular(a)\n",
      " |      Tests whether the argument is an essential singularity\n",
      " |      or a branch point, or the functions is non-holomorphic.\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from sympy.core.function.Function:\n",
      " |\n",
      " |  __new__(cls, *args, **options)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.function.Application:\n",
      " |\n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |\n",
      " |      The following should hold for all objects::\n",
      " |\n",
      " |          >> x == x.func(*x.args)\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from sympy.core.function.Application:\n",
      " |\n",
      " |  __dict__\n",
      " |      dictionary for instance variables\n",
      " |\n",
      " |  __weakref__\n",
      " |      list of weak references to the object\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.function.Application:\n",
      " |\n",
      " |  is_Function = True\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.expr.Expr:\n",
      " |\n",
      " |  __abs__(self) -> 'Expr'\n",
      " |\n",
      " |  __add__(self, other)\n",
      " |\n",
      " |  __complex__(self)\n",
      " |\n",
      " |  __divmod__(self, other)\n",
      " |\n",
      " |  __float__(self)\n",
      " |\n",
      " |  __floordiv__(self, other)\n",
      " |\n",
      " |  __format__(self, format_spec: 'str')\n",
      " |      Default object formatter.\n",
      " |\n",
      " |      Return str(self) if format_spec is empty. Raise TypeError otherwise.\n",
      " |\n",
      " |  __ge__(self, other)\n",
      " |      Return self>=value.\n",
      " |\n",
      " |  __gt__(self, other)\n",
      " |      Return self>value.\n",
      " |\n",
      " |  __int__(self)\n",
      " |\n",
      " |  __le__(self, other)\n",
      " |      Return self<=value.\n",
      " |\n",
      " |  __lt__(self, other)\n",
      " |      Return self<value.\n",
      " |\n",
      " |  __mod__(self, other)\n",
      " |\n",
      " |  __mul__(self, other)\n",
      " |\n",
      " |  __neg__(self)\n",
      " |\n",
      " |  __pos__(self)\n",
      " |\n",
      " |  __pow__(self, other, mod=None) -> 'Expr'\n",
      " |\n",
      " |  __radd__(self, other)\n",
      " |\n",
      " |  __rdivmod__(self, other)\n",
      " |\n",
      " |  __rfloordiv__(self, other)\n",
      " |\n",
      " |  __rmod__(self, other)\n",
      " |\n",
      " |  __rmul__(self, other)\n",
      " |\n",
      " |  __round__ = round(self, n=None)\n",
      " |\n",
      " |  __rpow__(self, other)\n",
      " |\n",
      " |  __rsub__(self, other)\n",
      " |\n",
      " |  __rtruediv__(self, other)\n",
      " |\n",
      " |  __sub__(self, other)\n",
      " |\n",
      " |  __truediv__(self, other)\n",
      " |\n",
      " |  __trunc__(self)\n",
      " |\n",
      " |  adjoint(self)\n",
      " |\n",
      " |  apart(self, x=None, **args)\n",
      " |      See the apart function in sympy.polys\n",
      " |\n",
      " |  args_cnc(self, cset=False, warn=True, split_1=True)\n",
      " |      Return [commutative factors, non-commutative factors] of self.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      self is treated as a Mul and the ordering of the factors is maintained.\n",
      " |      If ``cset`` is True the commutative factors will be returned in a set.\n",
      " |      If there were repeated factors (as may happen with an unevaluated Mul)\n",
      " |      then an error will be raised unless it is explicitly suppressed by\n",
      " |      setting ``warn`` to False.\n",
      " |\n",
      " |      Note: -1 is always separated from a Number unless split_1 is False.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import symbols, oo\n",
      " |      >>> A, B = symbols('A B', commutative=0)\n",
      " |      >>> x, y = symbols('x y')\n",
      " |      >>> (-2*x*y).args_cnc()\n",
      " |      [[-1, 2, x, y], []]\n",
      " |      >>> (-2.5*x).args_cnc()\n",
      " |      [[-1, 2.5, x], []]\n",
      " |      >>> (-2*x*A*B*y).args_cnc()\n",
      " |      [[-1, 2, x, y], [A, B]]\n",
      " |      >>> (-2*x*A*B*y).args_cnc(split_1=False)\n",
      " |      [[-2, x, y], [A, B]]\n",
      " |      >>> (-2*x*y).args_cnc(cset=True)\n",
      " |      [{-1, 2, x, y}, []]\n",
      " |\n",
      " |      The arg is always treated as a Mul:\n",
      " |\n",
      " |      >>> (-2 + x + A).args_cnc()\n",
      " |      [[], [x - 2 + A]]\n",
      " |      >>> (-oo).args_cnc() # -oo is a singleton\n",
      " |      [[-1, oo], []]\n",
      " |\n",
      " |  as_coeff_Add(self, rational=False) -> \"tuple['Number', Expr]\"\n",
      " |      Efficiently extract the coefficient of a summation.\n",
      " |\n",
      " |  as_coeff_Mul(self, rational: 'bool' = False) -> \"tuple['Number', Expr]\"\n",
      " |      Efficiently extract the coefficient of a product.\n",
      " |\n",
      " |  as_coeff_add(self, *deps) -> 'tuple[Expr, tuple[Expr, ...]]'\n",
      " |      Return the tuple (c, args) where self is written as an Add, ``a``.\n",
      " |\n",
      " |      c should be a Rational added to any terms of the Add that are\n",
      " |      independent of deps.\n",
      " |\n",
      " |      args should be a tuple of all other terms of ``a``; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |\n",
      " |      This should be used when you do not know if self is an Add or not but\n",
      " |      you want to treat self as an Add or if you want to process the\n",
      " |      individual arguments of the tail of self as an Add.\n",
      " |\n",
      " |      - if you know self is an Add and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail.\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |\n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_add()\n",
      " |      (3, ())\n",
      " |      >>> (3 + x).as_coeff_add()\n",
      " |      (3, (x,))\n",
      " |      >>> (3 + x + y).as_coeff_add(x)\n",
      " |      (y + 3, (x,))\n",
      " |      >>> (3 + y).as_coeff_add(x)\n",
      " |      (y + 3, ())\n",
      " |\n",
      " |  as_coeff_exponent(self, x) -> 'tuple[Expr, Expr]'\n",
      " |      ``c*x**e -> c,e`` where x can be any symbolic expression.\n",
      " |\n",
      " |  as_coeff_mul(self, *deps, **kwargs) -> 'tuple[Expr, tuple[Expr, ...]]'\n",
      " |      Return the tuple (c, args) where self is written as a Mul, ``m``.\n",
      " |\n",
      " |      c should be a Rational multiplied by any factors of the Mul that are\n",
      " |      independent of deps.\n",
      " |\n",
      " |      args should be a tuple of all other factors of m; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |\n",
      " |      This should be used when you do not know if self is a Mul or not but\n",
      " |      you want to treat self as a Mul or if you want to process the\n",
      " |      individual arguments of the tail of self as a Mul.\n",
      " |\n",
      " |      - if you know self is a Mul and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail;\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |\n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_mul()\n",
      " |      (3, ())\n",
      " |      >>> (3*x*y).as_coeff_mul()\n",
      " |      (3, (x, y))\n",
      " |      >>> (3*x*y).as_coeff_mul(x)\n",
      " |      (3*y, (x,))\n",
      " |      >>> (3*y).as_coeff_mul(x)\n",
      " |      (3*y, ())\n",
      " |\n",
      " |  as_coefficient(self, expr)\n",
      " |      Extracts symbolic coefficient at the given expression. In\n",
      " |      other words, this functions separates 'self' into the product\n",
      " |      of 'expr' and 'expr'-free coefficient. If such separation\n",
      " |      is not possible it will return None.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import E, pi, sin, I, Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |\n",
      " |      >>> E.as_coefficient(E)\n",
      " |      1\n",
      " |      >>> (2*E).as_coefficient(E)\n",
      " |      2\n",
      " |      >>> (2*sin(E)*E).as_coefficient(E)\n",
      " |\n",
      " |      Two terms have E in them so a sum is returned. (If one were\n",
      " |      desiring the coefficient of the term exactly matching E then\n",
      " |      the constant from the returned expression could be selected.\n",
      " |      Or, for greater precision, a method of Poly can be used to\n",
      " |      indicate the desired term from which the coefficient is\n",
      " |      desired.)\n",
      " |\n",
      " |      >>> (2*E + x*E).as_coefficient(E)\n",
      " |      x + 2\n",
      " |      >>> _.args[0]  # just want the exact match\n",
      " |      2\n",
      " |      >>> p = Poly(2*E + x*E); p\n",
      " |      Poly(x*E + 2*E, x, E, domain='ZZ')\n",
      " |      >>> p.coeff_monomial(E)\n",
      " |      2\n",
      " |      >>> p.nth(0, 1)\n",
      " |      2\n",
      " |\n",
      " |      Since the following cannot be written as a product containing\n",
      " |      E as a factor, None is returned. (If the coefficient ``2*x`` is\n",
      " |      desired then the ``coeff`` method should be used.)\n",
      " |\n",
      " |      >>> (2*E*x + x).as_coefficient(E)\n",
      " |      >>> (2*E*x + x).coeff(E)\n",
      " |      2*x\n",
      " |\n",
      " |      >>> (E*(x + 1) + x).as_coefficient(E)\n",
      " |\n",
      " |      >>> (2*pi*I).as_coefficient(pi*I)\n",
      " |      2\n",
      " |      >>> (2*I).as_coefficient(pi*I)\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      coeff: return sum of terms have a given factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |\n",
      " |  as_coefficients_dict(self, *syms)\n",
      " |      Return a dictionary mapping terms to their Rational coefficient.\n",
      " |      Since the dictionary is a defaultdict, inquiries about terms which\n",
      " |      were not present will return a coefficient of 0.\n",
      " |\n",
      " |      If symbols ``syms`` are provided, any multiplicative terms\n",
      " |      independent of them will be considered a coefficient and a\n",
      " |      regular dictionary of syms-dependent generators as keys and\n",
      " |      their corresponding coefficients as values will be returned.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import a, x, y\n",
      " |      >>> (3*x + a*x + 4).as_coefficients_dict()\n",
      " |      {1: 4, x: 3, a*x: 1}\n",
      " |      >>> _[a]\n",
      " |      0\n",
      " |      >>> (3*a*x).as_coefficients_dict()\n",
      " |      {a*x: 3}\n",
      " |      >>> (3*a*x).as_coefficients_dict(x)\n",
      " |      {x: 3*a}\n",
      " |      >>> (3*a*x).as_coefficients_dict(y)\n",
      " |      {1: 3*a*x}\n",
      " |\n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      This method should recursively remove a Rational from all arguments\n",
      " |      and return that (content) and the new self (primitive). The content\n",
      " |      should always be positive and ``Mul(*foo.as_content_primitive()) == foo``.\n",
      " |      The primitive need not be in canonical form and should try to preserve\n",
      " |      the underlying structure if possible (i.e. expand_mul should not be\n",
      " |      applied to self).\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |\n",
      " |      >>> eq = 2 + 2*x + 2*y*(3 + 3*y)\n",
      " |\n",
      " |      The as_content_primitive function is recursive and retains structure:\n",
      " |\n",
      " |      >>> eq.as_content_primitive()\n",
      " |      (2, x + 3*y*(y + 1) + 1)\n",
      " |\n",
      " |      Integer powers will have Rationals extracted from the base:\n",
      " |\n",
      " |      >>> ((2 + 6*x)**2).as_content_primitive()\n",
      " |      (4, (3*x + 1)**2)\n",
      " |      >>> ((2 + 6*x)**(2*y)).as_content_primitive()\n",
      " |      (1, (2*(3*x + 1))**(2*y))\n",
      " |\n",
      " |      Terms may end up joining once their as_content_primitives are added:\n",
      " |\n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (11, x*(y + 1))\n",
      " |      >>> ((3*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (9, x*(y + 1))\n",
      " |      >>> ((3*(z*(1 + y)) + 2.0*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (1, 6.0*x*(y + 1) + 3*z*(y + 1))\n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (121, x**2*(y + 1)**2)\n",
      " |      >>> ((x*(1 + y) + 0.4*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (1, 4.84*x**2*(y + 1)**2)\n",
      " |\n",
      " |      Radical content can also be factored out of the primitive:\n",
      " |\n",
      " |      >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)\n",
      " |      (2, sqrt(2)*(1 + 2*sqrt(5)))\n",
      " |\n",
      " |      If clear=False (default is True) then content will not be removed\n",
      " |      from an Add if it can be distributed to leave one or more\n",
      " |      terms with integer coefficients.\n",
      " |\n",
      " |      >>> (x/2 + y).as_content_primitive()\n",
      " |      (1/2, x + 2*y)\n",
      " |      >>> (x/2 + y).as_content_primitive(clear=False)\n",
      " |      (1, x/2 + y)\n",
      " |\n",
      " |  as_expr(self, *gens)\n",
      " |      Convert a polynomial to a SymPy expression.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |\n",
      " |      >>> f = (x**2 + x*y).as_poly(x, y)\n",
      " |      >>> f.as_expr()\n",
      " |      x**2 + x*y\n",
      " |\n",
      " |      >>> sin(x).as_expr()\n",
      " |      sin(x)\n",
      " |\n",
      " |  as_independent(self, *deps, **hint) -> 'tuple[Expr, Expr]'\n",
      " |      A mostly naive separation of a Mul or Add into arguments that are not\n",
      " |      are dependent on deps. To obtain as complete a separation of variables\n",
      " |      as possible, use a separation method first, e.g.:\n",
      " |\n",
      " |      * separatevars() to change Mul, Add and Pow (including exp) into Mul\n",
      " |      * .expand(mul=True) to change Add or Mul into Add\n",
      " |      * .expand(log=True) to change log expr into an Add\n",
      " |\n",
      " |      The only non-naive thing that is done here is to respect noncommutative\n",
      " |      ordering of variables and to always return (0, 0) for `self` of zero\n",
      " |      regardless of hints.\n",
      " |\n",
      " |      For nonzero `self`, the returned tuple (i, d) has the\n",
      " |      following interpretation:\n",
      " |\n",
      " |      * i will has no variable that appears in deps\n",
      " |      * d will either have terms that contain variables that are in deps, or\n",
      " |        be equal to 0 (when self is an Add) or 1 (when self is a Mul)\n",
      " |      * if self is an Add then self = i + d\n",
      " |      * if self is a Mul then self = i*d\n",
      " |      * otherwise (self, S.One) or (S.One, self) is returned.\n",
      " |\n",
      " |      To force the expression to be treated as an Add, use the hint as_Add=True\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      -- self is an Add\n",
      " |\n",
      " |      >>> from sympy import sin, cos, exp\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |\n",
      " |      >>> (x + x*y).as_independent(x)\n",
      " |      (0, x*y + x)\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x)\n",
      " |      (y + z, 2*x*sin(x) + x)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x, y)\n",
      " |      (z, 2*x*sin(x) + x + y)\n",
      " |\n",
      " |      -- self is a Mul\n",
      " |\n",
      " |      >>> (x*sin(x)*cos(y)).as_independent(x)\n",
      " |      (cos(y), x*sin(x))\n",
      " |\n",
      " |      non-commutative terms cannot always be separated out when self is a Mul\n",
      " |\n",
      " |      >>> from sympy import symbols\n",
      " |      >>> n1, n2, n3 = symbols('n1 n2 n3', commutative=False)\n",
      " |      >>> (n1 + n1*n2).as_independent(n2)\n",
      " |      (n1, n1*n2)\n",
      " |      >>> (n2*n1 + n1*n2).as_independent(n2)\n",
      " |      (0, n1*n2 + n2*n1)\n",
      " |      >>> (n1*n2*n3).as_independent(n1)\n",
      " |      (1, n1*n2*n3)\n",
      " |      >>> (n1*n2*n3).as_independent(n2)\n",
      " |      (n1, n2*n3)\n",
      " |      >>> ((x-n1)*(x-y)).as_independent(x)\n",
      " |      (1, (x - y)*(x - n1))\n",
      " |\n",
      " |      -- self is anything else:\n",
      " |\n",
      " |      >>> (sin(x)).as_independent(x)\n",
      " |      (1, sin(x))\n",
      " |      >>> (sin(x)).as_independent(y)\n",
      " |      (sin(x), 1)\n",
      " |      >>> exp(x+y).as_independent(x)\n",
      " |      (1, exp(x + y))\n",
      " |\n",
      " |      -- force self to be treated as an Add:\n",
      " |\n",
      " |      >>> (3*x).as_independent(x, as_Add=True)\n",
      " |      (0, 3*x)\n",
      " |\n",
      " |      -- force self to be treated as a Mul:\n",
      " |\n",
      " |      >>> (3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x + 3)\n",
      " |      >>> (-3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x - 3)\n",
      " |\n",
      " |      Note how the below differs from the above in making the\n",
      " |      constant on the dep term positive.\n",
      " |\n",
      " |      >>> (y*(-3+x)).as_independent(x)\n",
      " |      (y, x - 3)\n",
      " |\n",
      " |      -- use .as_independent() for true independence testing instead\n",
      " |         of .has(). The former considers only symbols in the free\n",
      " |         symbols while the latter considers all symbols\n",
      " |\n",
      " |      >>> from sympy import Integral\n",
      " |      >>> I = Integral(x, (x, 1, 2))\n",
      " |      >>> I.has(x)\n",
      " |      True\n",
      " |      >>> x in I.free_symbols\n",
      " |      False\n",
      " |      >>> I.as_independent(x) == (I, 1)\n",
      " |      True\n",
      " |      >>> (I + x).as_independent(x) == (I, x)\n",
      " |      True\n",
      " |\n",
      " |      Note: when trying to get independent terms, a separation method\n",
      " |      might need to be used first. In this case, it is important to keep\n",
      " |      track of what you send to this routine so you know how to interpret\n",
      " |      the returned values\n",
      " |\n",
      " |      >>> from sympy import separatevars, log\n",
      " |      >>> separatevars(exp(x+y)).as_independent(x)\n",
      " |      (exp(y), exp(x))\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> separatevars(x + x*y).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).expand(mul=True).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> a, b=symbols('a b', positive=True)\n",
      " |      >>> (log(a*b).expand(log=True)).as_independent(b)\n",
      " |      (log(a), log(b))\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      separatevars\n",
      " |      expand_log\n",
      " |      sympy.core.add.Add.as_two_terms\n",
      " |      sympy.core.mul.Mul.as_two_terms\n",
      " |      as_coeff_mul\n",
      " |\n",
      " |  as_leading_term(self, *symbols, logx=None, cdir=0)\n",
      " |      Returns the leading (nonzero) term of the series expansion of self.\n",
      " |\n",
      " |      The _eval_as_leading_term routines are used to do this, and they must\n",
      " |      always return a non-zero value.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + x**2).as_leading_term(x)\n",
      " |      1\n",
      " |      >>> (1/x**2 + x + x**2).as_leading_term(x)\n",
      " |      x**(-2)\n",
      " |\n",
      " |  as_numer_denom(self)\n",
      " |      Return the numerator and the denominator of an expression.\n",
      " |\n",
      " |      expression -> a/b -> a, b\n",
      " |\n",
      " |      This is just a stub that should be defined by\n",
      " |      an object's class methods to get anything else.\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      normal: return ``a/b`` instead of ``(a, b)``\n",
      " |\n",
      " |  as_ordered_factors(self, order=None)\n",
      " |      Return list of ordered factors (if Mul) else [self].\n",
      " |\n",
      " |  as_ordered_terms(self, order=None, data=False)\n",
      " |      Transform an expression to an ordered list of terms.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import sin, cos\n",
      " |      >>> from sympy.abc import x\n",
      " |\n",
      " |      >>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms()\n",
      " |      [sin(x)**2*cos(x), sin(x)**2, 1]\n",
      " |\n",
      " |  as_poly(self, *gens, **args)\n",
      " |      Converts ``self`` to a polynomial or returns ``None``.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |\n",
      " |      >>> print((x**2 + x*y).as_poly())\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |\n",
      " |      >>> print((x**2 + x*y).as_poly(x, y))\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |\n",
      " |      >>> print((x**2 + sin(y)).as_poly(x, y))\n",
      " |      None\n",
      " |\n",
      " |  as_powers_dict(self)\n",
      " |      Return self as a dictionary of factors with each factor being\n",
      " |      treated as a power. The keys are the bases of the factors and the\n",
      " |      values, the corresponding exponents. The resulting dictionary should\n",
      " |      be used with caution if the expression is a Mul and contains non-\n",
      " |      commutative factors since the order that they appeared will be lost in\n",
      " |      the dictionary.\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |      as_ordered_factors: An alternative for noncommutative applications,\n",
      " |                          returning an ordered list of factors.\n",
      " |      args_cnc: Similar to as_ordered_factors, but guarantees separation\n",
      " |                of commutative and noncommutative factors.\n",
      " |\n",
      " |  as_real_imag(self, deep=True, **hints)\n",
      " |      Performs complex expansion on 'self' and returns a tuple\n",
      " |      containing collected both real and imaginary parts. This\n",
      " |      method cannot be confused with re() and im() functions,\n",
      " |      which does not perform complex expansion at evaluation.\n",
      " |\n",
      " |      However it is possible to expand both re() and im()\n",
      " |      functions and get exactly the same results as with\n",
      " |      a single call to this function.\n",
      " |\n",
      " |      >>> from sympy import symbols, I\n",
      " |\n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |\n",
      " |      >>> (x + y*I).as_real_imag()\n",
      " |      (x, y)\n",
      " |\n",
      " |      >>> from sympy.abc import z, w\n",
      " |\n",
      " |      >>> (z + w*I).as_real_imag()\n",
      " |      (re(z) - im(w), re(w) + im(z))\n",
      " |\n",
      " |  as_terms(self)\n",
      " |      Transform an expression to a list of terms.\n",
      " |\n",
      " |  aseries(self, x=None, n=6, bound=0, hir=False)\n",
      " |      Asymptotic Series expansion of self.\n",
      " |      This is equivalent to ``self.series(x, oo, n)``.\n",
      " |\n",
      " |      Parameters\n",
      " |      ==========\n",
      " |\n",
      " |      self : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |\n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |\n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |\n",
      " |      hir : Boolean\n",
      " |            Set this parameter to be True to produce hierarchical series.\n",
      " |            It stops the recursion at an early level and may provide nicer\n",
      " |            and more useful results.\n",
      " |\n",
      " |      bound : Value, Integer\n",
      " |              Use the ``bound`` parameter to give limit on rewriting\n",
      " |              coefficients in its normalised form.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import sin, exp\n",
      " |      >>> from sympy.abc import x\n",
      " |\n",
      " |      >>> e = sin(1/x + exp(-x)) - sin(1/x)\n",
      " |\n",
      " |      >>> e.aseries(x)\n",
      " |      (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)\n",
      " |\n",
      " |      >>> e.aseries(x, n=3, hir=True)\n",
      " |      -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))\n",
      " |\n",
      " |      >>> e = exp(exp(x)/(1 - 1/x))\n",
      " |\n",
      " |      >>> e.aseries(x)\n",
      " |      exp(exp(x)/(1 - 1/x))\n",
      " |\n",
      " |      >>> e.aseries(x, bound=3) # doctest: +SKIP\n",
      " |      exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))\n",
      " |\n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).aseries(x, n=8)\n",
      " |      1/x\n",
      " |\n",
      " |      Returns\n",
      " |      =======\n",
      " |\n",
      " |      Expr\n",
      " |          Asymptotic series expansion of the expression.\n",
      " |\n",
      " |      Notes\n",
      " |      =====\n",
      " |\n",
      " |      This algorithm is directly induced from the limit computational algorithm provided by Gruntz.\n",
      " |      It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first\n",
      " |      to look for the most rapidly varying subexpression w of a given expression f and then expands f\n",
      " |      in a series in w. Then same thing is recursively done on the leading coefficient\n",
      " |      till we get constant coefficients.\n",
      " |\n",
      " |      If the most rapidly varying subexpression of a given expression f is f itself,\n",
      " |      the algorithm tries to find a normalised representation of the mrv set and rewrites f\n",
      " |      using this normalised representation.\n",
      " |\n",
      " |      If the expansion contains an order term, it will be either ``O(x ** (-n))`` or ``O(w ** (-n))``\n",
      " |      where ``w`` belongs to the most rapidly varying expression of ``self``.\n",
      " |\n",
      " |      References\n",
      " |      ==========\n",
      " |\n",
      " |      .. [1] Gruntz, Dominik. A new algorithm for computing asymptotic series.\n",
      " |             In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993.\n",
      " |             pp. 239-244.\n",
      " |      .. [2] Gruntz thesis - p90\n",
      " |      .. [3] https://en.wikipedia.org/wiki/Asymptotic_expansion\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      Expr.aseries: See the docstring of this function for complete details of this wrapper.\n",
      " |\n",
      " |  cancel(self, *gens, **args)\n",
      " |      See the cancel function in sympy.polys\n",
      " |\n",
      " |  coeff(self, x, n=1, right=False, _first=True)\n",
      " |      Returns the coefficient from the term(s) containing ``x**n``. If ``n``\n",
      " |      is zero then all terms independent of ``x`` will be returned.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      When ``x`` is noncommutative, the coefficient to the left (default) or\n",
      " |      right of ``x`` can be returned. The keyword 'right' is ignored when\n",
      " |      ``x`` is commutative.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import symbols\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |\n",
      " |      You can select terms that have an explicit negative in front of them:\n",
      " |\n",
      " |      >>> (-x + 2*y).coeff(-1)\n",
      " |      x\n",
      " |      >>> (x - 2*y).coeff(-1)\n",
      " |      2*y\n",
      " |\n",
      " |      You can select terms with no Rational coefficient:\n",
      " |\n",
      " |      >>> (x + 2*y).coeff(1)\n",
      " |      x\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(1)\n",
      " |      0\n",
      " |\n",
      " |      You can select terms independent of x by making n=0; in this case\n",
      " |      expr.as_independent(x)[0] is returned (and 0 will be returned instead\n",
      " |      of None):\n",
      " |\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x, 0)\n",
      " |      3\n",
      " |      >>> eq = ((x + 1)**3).expand() + 1\n",
      " |      >>> eq\n",
      " |      x**3 + 3*x**2 + 3*x + 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 2]\n",
      " |      >>> eq -= 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 0]\n",
      " |\n",
      " |      You can select terms that have a numerical term in front of them:\n",
      " |\n",
      " |      >>> (-x - 2*y).coeff(2)\n",
      " |      -y\n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> (x + sqrt(2)*x).coeff(sqrt(2))\n",
      " |      x\n",
      " |\n",
      " |      The matching is exact:\n",
      " |\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x)\n",
      " |      2\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**2)\n",
      " |      4\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**3)\n",
      " |      0\n",
      " |      >>> (z*(x + y)**2).coeff((x + y)**2)\n",
      " |      z\n",
      " |      >>> (z*(x + y)**2).coeff(x + y)\n",
      " |      0\n",
      " |\n",
      " |      In addition, no factoring is done, so 1 + z*(1 + y) is not obtained\n",
      " |      from the following:\n",
      " |\n",
      " |      >>> (x + z*(x + x*y)).coeff(x)\n",
      " |      1\n",
      " |\n",
      " |      If such factoring is desired, factor_terms can be used first:\n",
      " |\n",
      " |      >>> from sympy import factor_terms\n",
      " |      >>> factor_terms(x + z*(x + x*y)).coeff(x)\n",
      " |      z*(y + 1) + 1\n",
      " |\n",
      " |      >>> n, m, o = symbols('n m o', commutative=False)\n",
      " |      >>> n.coeff(n)\n",
      " |      1\n",
      " |      >>> (3*n).coeff(n)\n",
      " |      3\n",
      " |      >>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m\n",
      " |      1 + m\n",
      " |      >>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m\n",
      " |      m\n",
      " |\n",
      " |      If there is more than one possible coefficient 0 is returned:\n",
      " |\n",
      " |      >>> (n*m + m*n).coeff(n)\n",
      " |      0\n",
      " |\n",
      " |      If there is only one possible coefficient, it is returned:\n",
      " |\n",
      " |      >>> (n*m + x*m*n).coeff(m*n)\n",
      " |      x\n",
      " |      >>> (n*m + x*m*n).coeff(m*n, right=1)\n",
      " |      1\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      as_coefficient: separate the expression into a coefficient and factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |\n",
      " |  collect(self, syms, func=None, evaluate=True, exact=False, distribute_order_term=True)\n",
      " |      See the collect function in sympy.simplify\n",
      " |\n",
      " |  combsimp(self)\n",
      " |      See the combsimp function in sympy.simplify\n",
      " |\n",
      " |  compute_leading_term(self, x, logx=None)\n",
      " |      Deprecated function to compute the leading term of a series.\n",
      " |\n",
      " |      as_leading_term is only allowed for results of .series()\n",
      " |      This is a wrapper to compute a series first.\n",
      " |\n",
      " |  conjugate(self)\n",
      " |      Returns the complex conjugate of 'self'.\n",
      " |\n",
      " |  could_extract_minus_sign(self)\n",
      " |      Return True if self has -1 as a leading factor or has\n",
      " |      more literal negative signs than positive signs in a sum,\n",
      " |      otherwise False.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = x - y\n",
      " |      >>> {i.could_extract_minus_sign() for i in (e, -e)}\n",
      " |      {False, True}\n",
      " |\n",
      " |      Though the ``y - x`` is considered like ``-(x - y)``, since it\n",
      " |      is in a product without a leading factor of -1, the result is\n",
      " |      false below:\n",
      " |\n",
      " |      >>> (x*(y - x)).could_extract_minus_sign()\n",
      " |      False\n",
      " |\n",
      " |      To put something in canonical form wrt to sign, use `signsimp`:\n",
      " |\n",
      " |      >>> from sympy import signsimp\n",
      " |      >>> signsimp(x*(y - x))\n",
      " |      -x*(x - y)\n",
      " |      >>> _.could_extract_minus_sign()\n",
      " |      True\n",
      " |\n",
      " |  count_ops(self, visual=None)\n",
      " |      Wrapper for count_ops that returns the operation count.\n",
      " |\n",
      " |  diff(self, *symbols, **assumptions)\n",
      " |\n",
      " |  dir(self, x, cdir)\n",
      " |\n",
      " |  equals(self, other, failing_expression=False)\n",
      " |      Return True if self == other, False if it does not, or None. If\n",
      " |      failing_expression is True then the expression which did not simplify\n",
      " |      to a 0 will be returned instead of None.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      If ``self`` is a Number (or complex number) that is not zero, then\n",
      " |      the result is False.\n",
      " |\n",
      " |      If ``self`` is a number and has not evaluated to zero, evalf will be\n",
      " |      used to test whether the expression evaluates to zero. If it does so\n",
      " |      and the result has significance (i.e. the precision is either -1, for\n",
      " |      a Rational result, or is greater than 1) then the evalf value will be\n",
      " |      used to return True or False.\n",
      " |\n",
      " |  expand(self, deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)\n",
      " |      Expand an expression using hints.\n",
      " |\n",
      " |      See the docstring of the expand() function in sympy.core.function for\n",
      " |      more information.\n",
      " |\n",
      " |  extract_additively(self, c)\n",
      " |      Return self - c if it's possible to subtract c from self and\n",
      " |      make all matching coefficients move towards zero, else return None.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = 2*x + 3\n",
      " |      >>> e.extract_additively(x + 1)\n",
      " |      x + 2\n",
      " |      >>> e.extract_additively(3*x)\n",
      " |      >>> e.extract_additively(4)\n",
      " |      >>> (y*(x + 1)).extract_additively(x + 1)\n",
      " |      >>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1)\n",
      " |      (x + 1)*(x + 2*y) + 3\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |      extract_multiplicatively\n",
      " |      coeff\n",
      " |      as_coefficient\n",
      " |\n",
      " |  extract_branch_factor(self, allow_half=False)\n",
      " |      Try to write self as ``exp_polar(2*pi*I*n)*z`` in a nice way.\n",
      " |      Return (z, n).\n",
      " |\n",
      " |      >>> from sympy import exp_polar, I, pi\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> exp_polar(I*pi).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), 0)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor()\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(-pi*I).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), -1)\n",
      " |      >>> exp_polar(3*pi*I + x).extract_branch_factor()\n",
      " |      (exp_polar(x + I*pi), 1)\n",
      " |      >>> (y*exp_polar(-5*pi*I)*exp_polar(3*pi*I + 2*pi*x)).extract_branch_factor()\n",
      " |      (y*exp_polar(2*pi*x), -1)\n",
      " |      >>> exp_polar(-I*pi/2).extract_branch_factor()\n",
      " |      (exp_polar(-I*pi/2), 0)\n",
      " |\n",
      " |      If allow_half is True, also extract exp_polar(I*pi):\n",
      " |\n",
      " |      >>> exp_polar(I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1/2)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(3*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 3/2)\n",
      " |      >>> exp_polar(-I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, -1/2)\n",
      " |\n",
      " |  extract_multiplicatively(self, c)\n",
      " |      Return None if it's not possible to make self in the form\n",
      " |      c * something in a nice way, i.e. preserving the properties\n",
      " |      of arguments of self.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import symbols, Rational\n",
      " |\n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |\n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**2 * y)\n",
      " |      x*y**2\n",
      " |\n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**4 * y)\n",
      " |\n",
      " |      >>> (2*x).extract_multiplicatively(2)\n",
      " |      x\n",
      " |\n",
      " |      >>> (2*x).extract_multiplicatively(3)\n",
      " |\n",
      " |      >>> (Rational(1, 2)*x).extract_multiplicatively(3)\n",
      " |      x/6\n",
      " |\n",
      " |  factor(self, *gens, **args)\n",
      " |      See the factor() function in sympy.polys.polytools\n",
      " |\n",
      " |  fourier_series(self, limits=None)\n",
      " |      Compute fourier sine/cosine series of self.\n",
      " |\n",
      " |      See the docstring of the :func:`fourier_series` in sympy.series.fourier\n",
      " |      for more information.\n",
      " |\n",
      " |  fps(self, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)\n",
      " |      Compute formal power power series of self.\n",
      " |\n",
      " |      See the docstring of the :func:`fps` function in sympy.series.formal for\n",
      " |      more information.\n",
      " |\n",
      " |  gammasimp(self)\n",
      " |      See the gammasimp function in sympy.simplify\n",
      " |\n",
      " |  getO(self)\n",
      " |      Returns the additive O(..) symbol if there is one, else None.\n",
      " |\n",
      " |  getn(self)\n",
      " |      Returns the order of the expression.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      The order is determined either from the O(...) term. If there\n",
      " |      is no O(...) term, it returns None.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import O\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + O(x**2)).getn()\n",
      " |      2\n",
      " |      >>> (1 + x).getn()\n",
      " |\n",
      " |  integrate(self, *args, **kwargs)\n",
      " |      See the integrate function in sympy.integrals\n",
      " |\n",
      " |  invert(self, g, *gens, **args)\n",
      " |      Return the multiplicative inverse of ``self`` mod ``g``\n",
      " |      where ``self`` (and ``g``) may be symbolic expressions).\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |      sympy.core.numbers.mod_inverse, sympy.polys.polytools.invert\n",
      " |\n",
      " |  is_algebraic_expr(self, *syms)\n",
      " |      This tests whether a given expression is algebraic or not, in the\n",
      " |      given symbols, syms. When syms is not given, all free symbols\n",
      " |      will be used. The rational function does not have to be in expanded\n",
      " |      or in any kind of canonical form.\n",
      " |\n",
      " |      This function returns False for expressions that are \"algebraic\n",
      " |      expressions\" with symbolic exponents. This is a simple extension to the\n",
      " |      is_rational_function, including rational exponentiation.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Symbol, sqrt\n",
      " |      >>> x = Symbol('x', real=True)\n",
      " |      >>> sqrt(1 + x).is_rational_function()\n",
      " |      False\n",
      " |      >>> sqrt(1 + x).is_algebraic_expr()\n",
      " |      True\n",
      " |\n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be an algebraic\n",
      " |      expression to become one.\n",
      " |\n",
      " |      >>> from sympy import exp, factor\n",
      " |      >>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1)\n",
      " |      >>> a.is_algebraic_expr(x)\n",
      " |      False\n",
      " |      >>> factor(a).is_algebraic_expr()\n",
      " |      True\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      is_rational_function\n",
      " |\n",
      " |      References\n",
      " |      ==========\n",
      " |\n",
      " |      .. [1] https://en.wikipedia.org/wiki/Algebraic_expression\n",
      " |\n",
      " |  is_constant(self, *wrt, **flags)\n",
      " |      Return True if self is constant, False if not, or None if\n",
      " |      the constancy could not be determined conclusively.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      If an expression has no free symbols then it is a constant. If\n",
      " |      there are free symbols it is possible that the expression is a\n",
      " |      constant, perhaps (but not necessarily) zero. To test such\n",
      " |      expressions, a few strategies are tried:\n",
      " |\n",
      " |      1) numerical evaluation at two random points. If two such evaluations\n",
      " |      give two different values and the values have a precision greater than\n",
      " |      1 then self is not constant. If the evaluations agree or could not be\n",
      " |      obtained with any precision, no decision is made. The numerical testing\n",
      " |      is done only if ``wrt`` is different than the free symbols.\n",
      " |\n",
      " |      2) differentiation with respect to variables in 'wrt' (or all free\n",
      " |      symbols if omitted) to see if the expression is constant or not. This\n",
      " |      will not always lead to an expression that is zero even though an\n",
      " |      expression is constant (see added test in test_expr.py). If\n",
      " |      all derivatives are zero then self is constant with respect to the\n",
      " |      given symbols.\n",
      " |\n",
      " |      3) finding out zeros of denominator expression with free_symbols.\n",
      " |      It will not be constant if there are zeros. It gives more negative\n",
      " |      answers for expression that are not constant.\n",
      " |\n",
      " |      If neither evaluation nor differentiation can prove the expression is\n",
      " |      constant, None is returned unless two numerical values happened to be\n",
      " |      the same and the flag ``failing_number`` is True -- in that case the\n",
      " |      numerical value will be returned.\n",
      " |\n",
      " |      If flag simplify=False is passed, self will not be simplified;\n",
      " |      the default is True since self should be simplified before testing.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import cos, sin, Sum, S, pi\n",
      " |      >>> from sympy.abc import a, n, x, y\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> S(2).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, 10)).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant()\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(y)\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(n)\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(x)\n",
      " |      True\n",
      " |      >>> eq = a*cos(x)**2 + a*sin(x)**2 - a\n",
      " |      >>> eq.is_constant()\n",
      " |      True\n",
      " |      >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0\n",
      " |      True\n",
      " |\n",
      " |      >>> (0**x).is_constant()\n",
      " |      False\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> (x**x).is_constant()\n",
      " |      False\n",
      " |      >>> one = cos(x)**2 + sin(x)**2\n",
      " |      >>> one.is_constant()\n",
      " |      True\n",
      " |      >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1\n",
      " |      True\n",
      " |\n",
      " |  is_meromorphic(self, x, a)\n",
      " |      This tests whether an expression is meromorphic as\n",
      " |      a function of the given symbol ``x`` at the point ``a``.\n",
      " |\n",
      " |      This method is intended as a quick test that will return\n",
      " |      None if no decision can be made without simplification or\n",
      " |      more detailed analysis.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import zoo, log, sin, sqrt\n",
      " |      >>> from sympy.abc import x\n",
      " |\n",
      " |      >>> f = 1/x**2 + 1 - 2*x**3\n",
      " |      >>> f.is_meromorphic(x, 0)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |\n",
      " |      >>> g = x**log(3)\n",
      " |      >>> g.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> g.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> g.is_meromorphic(x, zoo)\n",
      " |      False\n",
      " |\n",
      " |      >>> h = sin(1/x)*x**2\n",
      " |      >>> h.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> h.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> h.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |\n",
      " |      Multivalued functions are considered meromorphic when their\n",
      " |      branches are meromorphic. Thus most functions are meromorphic\n",
      " |      everywhere except at essential singularities and branch points.\n",
      " |      In particular, they will be meromorphic also on branch cuts\n",
      " |      except at their endpoints.\n",
      " |\n",
      " |      >>> log(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> log(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> sqrt(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> sqrt(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |\n",
      " |  is_polynomial(self, *syms)\n",
      " |      Return True if self is a polynomial in syms and False otherwise.\n",
      " |\n",
      " |      This checks if self is an exact polynomial in syms.  This function\n",
      " |      returns False for expressions that are \"polynomials\" with symbolic\n",
      " |      exponents.  Thus, you should be able to apply polynomial algorithms to\n",
      " |      expressions for which this returns True, and Poly(expr, \\*syms) should\n",
      " |      work if and only if expr.is_polynomial(\\*syms) returns True. The\n",
      " |      polynomial does not have to be in expanded form.  If no symbols are\n",
      " |      given, all free symbols in the expression will be used.\n",
      " |\n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', polynomial=True).\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Symbol, Function\n",
      " |      >>> x = Symbol('x')\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial(x)\n",
      " |      True\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial()\n",
      " |      True\n",
      " |      >>> (2**x + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (2**x + 1).is_polynomial(2**x)\n",
      " |      True\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (f(x) + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (f(x) + 1).is_polynomial(f(x))\n",
      " |      True\n",
      " |      >>> (1/f(x) + 1).is_polynomial(f(x))\n",
      " |      False\n",
      " |\n",
      " |      >>> n = Symbol('n', nonnegative=True, integer=True)\n",
      " |      >>> (x**n + 1).is_polynomial(x)\n",
      " |      False\n",
      " |\n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a polynomial to\n",
      " |      become one.\n",
      " |\n",
      " |      >>> from sympy import sqrt, factor, cancel\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)\n",
      " |      >>> a.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      y + 1\n",
      " |      >>> factor(a).is_polynomial(y)\n",
      " |      True\n",
      " |\n",
      " |      >>> b = (y**2 + 2*y + 1)/(y + 1)\n",
      " |      >>> b.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> cancel(b)\n",
      " |      y + 1\n",
      " |      >>> cancel(b).is_polynomial(y)\n",
      " |      True\n",
      " |\n",
      " |      See also .is_rational_function()\n",
      " |\n",
      " |  is_rational_function(self, *syms)\n",
      " |      Test whether function is a ratio of two polynomials in the given\n",
      " |      symbols, syms. When syms is not given, all free symbols will be used.\n",
      " |      The rational function does not have to be in expanded or in any kind of\n",
      " |      canonical form.\n",
      " |\n",
      " |      This function returns False for expressions that are \"rational\n",
      " |      functions\" with symbolic exponents.  Thus, you should be able to call\n",
      " |      .as_numer_denom() and apply polynomial algorithms to the result for\n",
      " |      expressions for which this returns True.\n",
      " |\n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', rational_function=True).\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Symbol, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |\n",
      " |      >>> (x/y).is_rational_function()\n",
      " |      True\n",
      " |\n",
      " |      >>> (x**2).is_rational_function()\n",
      " |      True\n",
      " |\n",
      " |      >>> (x/sin(y)).is_rational_function(y)\n",
      " |      False\n",
      " |\n",
      " |      >>> n = Symbol('n', integer=True)\n",
      " |      >>> (x**n + 1).is_rational_function(x)\n",
      " |      False\n",
      " |\n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a rational function\n",
      " |      to become one.\n",
      " |\n",
      " |      >>> from sympy import sqrt, factor\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)/y\n",
      " |      >>> a.is_rational_function(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      (y + 1)/y\n",
      " |      >>> factor(a).is_rational_function(y)\n",
      " |      True\n",
      " |\n",
      " |      See also is_algebraic_expr().\n",
      " |\n",
      " |  leadterm(self, x, logx=None, cdir=0)\n",
      " |      Returns the leading term a*x**b as a tuple (a, b).\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1+x+x**2).leadterm(x)\n",
      " |      (1, 0)\n",
      " |      >>> (1/x**2+x+x**2).leadterm(x)\n",
      " |      (1, -2)\n",
      " |\n",
      " |  limit(self, x, xlim, dir='+')\n",
      " |      Compute limit x->xlim.\n",
      " |\n",
      " |  lseries(self, x=None, x0=0, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper for series yielding an iterator of the terms of the series.\n",
      " |\n",
      " |      Note: an infinite series will yield an infinite iterator. The following,\n",
      " |      for exaxmple, will never terminate. It will just keep printing terms\n",
      " |      of the sin(x) series::\n",
      " |\n",
      " |        for term in sin(x).lseries(x):\n",
      " |            print term\n",
      " |\n",
      " |      The advantage of lseries() over nseries() is that many times you are\n",
      " |      just interested in the next term in the series (i.e. the first term for\n",
      " |      example), but you do not know how many you should ask for in nseries()\n",
      " |      using the \"n\" parameter.\n",
      " |\n",
      " |      See also nseries().\n",
      " |\n",
      " |  normal(self)\n",
      " |      Return the expression as a fraction.\n",
      " |\n",
      " |      expression -> a/b\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      as_numer_denom: return ``(a, b)`` instead of ``a/b``\n",
      " |\n",
      " |  nseries(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper to _eval_nseries if assumptions allow, else to series.\n",
      " |\n",
      " |      If x is given, x0 is 0, dir='+', and self has x, then _eval_nseries is\n",
      " |      called. This calculates \"n\" terms in the innermost expressions and\n",
      " |      then builds up the final series just by \"cross-multiplying\" everything\n",
      " |      out.\n",
      " |\n",
      " |      The optional ``logx`` parameter can be used to replace any log(x) in the\n",
      " |      returned series with a symbolic value to avoid evaluating log(x) at 0. A\n",
      " |      symbol to use in place of log(x) should be provided.\n",
      " |\n",
      " |      Advantage -- it's fast, because we do not have to determine how many\n",
      " |      terms we need to calculate in advance.\n",
      " |\n",
      " |      Disadvantage -- you may end up with less terms than you may have\n",
      " |      expected, but the O(x**n) term appended will always be correct and\n",
      " |      so the result, though perhaps shorter, will also be correct.\n",
      " |\n",
      " |      If any of those assumptions is not met, this is treated like a\n",
      " |      wrapper to series which will try harder to return the correct\n",
      " |      number of terms.\n",
      " |\n",
      " |      See also lseries().\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import sin, log, Symbol\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> sin(x).nseries(x, 0, 6)\n",
      " |      x - x**3/6 + x**5/120 + O(x**6)\n",
      " |      >>> log(x+1).nseries(x, 0, 5)\n",
      " |      x - x**2/2 + x**3/3 - x**4/4 + O(x**5)\n",
      " |\n",
      " |      Handling of the ``logx`` parameter --- in the following example the\n",
      " |      expansion fails since ``sin`` does not have an asymptotic expansion\n",
      " |      at -oo (the limit of log(x) as x approaches 0):\n",
      " |\n",
      " |      >>> e = sin(log(x))\n",
      " |      >>> e.nseries(x, 0, 6)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      PoleError: ...\n",
      " |      ...\n",
      " |      >>> logx = Symbol('logx')\n",
      " |      >>> e.nseries(x, 0, 6, logx=logx)\n",
      " |      sin(logx)\n",
      " |\n",
      " |      In the following example, the expansion works but only returns self\n",
      " |      unless the ``logx`` parameter is used:\n",
      " |\n",
      " |      >>> e = x**y\n",
      " |      >>> e.nseries(x, 0, 2)\n",
      " |      x**y\n",
      " |      >>> e.nseries(x, 0, 2, logx=logx)\n",
      " |      exp(logx*y)\n",
      " |\n",
      " |  nsimplify(self, constants=(), tolerance=None, full=False)\n",
      " |      See the nsimplify function in sympy.simplify\n",
      " |\n",
      " |  powsimp(self, *args, **kwargs)\n",
      " |      See the powsimp function in sympy.simplify\n",
      " |\n",
      " |  primitive(self)\n",
      " |      Return the positive Rational that can be extracted non-recursively\n",
      " |      from every term of self (i.e., self is treated like an Add). This is\n",
      " |      like the as_coeff_Mul() method but primitive always extracts a positive\n",
      " |      Rational (never a negative or a Float).\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (3*(x + 1)**2).primitive()\n",
      " |      (3, (x + 1)**2)\n",
      " |      >>> a = (6*x + 2); a.primitive()\n",
      " |      (2, 3*x + 1)\n",
      " |      >>> b = (x/2 + 3); b.primitive()\n",
      " |      (1/2, x + 6)\n",
      " |      >>> (a*b).primitive() == (1, a*b)\n",
      " |      True\n",
      " |\n",
      " |  radsimp(self, **kwargs)\n",
      " |      See the radsimp function in sympy.simplify\n",
      " |\n",
      " |  ratsimp(self)\n",
      " |      See the ratsimp function in sympy.simplify\n",
      " |\n",
      " |  removeO(self)\n",
      " |      Removes the additive O(..) symbol if there is one\n",
      " |\n",
      " |  round(self, n=None)\n",
      " |      Return x rounded to the given decimal place.\n",
      " |\n",
      " |      If a complex number would results, apply round to the real\n",
      " |      and imaginary components of the number.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import pi, E, I, S, Number\n",
      " |      >>> pi.round()\n",
      " |      3\n",
      " |      >>> pi.round(2)\n",
      " |      3.14\n",
      " |      >>> (2*pi + E*I).round()\n",
      " |      6 + 3*I\n",
      " |\n",
      " |      The round method has a chopping effect:\n",
      " |\n",
      " |      >>> (2*pi + I/10).round()\n",
      " |      6\n",
      " |      >>> (pi/10 + 2*I).round()\n",
      " |      2*I\n",
      " |      >>> (pi/10 + E*I).round(2)\n",
      " |      0.31 + 2.72*I\n",
      " |\n",
      " |      Notes\n",
      " |      =====\n",
      " |\n",
      " |      The Python ``round`` function uses the SymPy ``round`` method so it\n",
      " |      will always return a SymPy number (not a Python float or int):\n",
      " |\n",
      " |      >>> isinstance(round(S(123), -2), Number)\n",
      " |      True\n",
      " |\n",
      " |  separate(self, deep=False, force=False)\n",
      " |      See the separate function in sympy.simplify\n",
      " |\n",
      " |  series(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Series expansion of \"self\" around ``x = x0`` yielding either terms of\n",
      " |      the series one by one (the lazy series given when n=None), else\n",
      " |      all the terms at once when n != None.\n",
      " |\n",
      " |      Returns the series expansion of \"self\" around the point ``x = x0``\n",
      " |      with respect to ``x`` up to ``O((x - x0)**n, x, x0)`` (default n is 6).\n",
      " |\n",
      " |      If ``x=None`` and ``self`` is univariate, the univariate symbol will\n",
      " |      be supplied, otherwise an error will be raised.\n",
      " |\n",
      " |      Parameters\n",
      " |      ==========\n",
      " |\n",
      " |      expr : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |\n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |\n",
      " |      x0 : Value\n",
      " |           The value around which ``x`` is calculated. Can be any value\n",
      " |           from ``-oo`` to ``oo``.\n",
      " |\n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |\n",
      " |      dir : String, optional\n",
      " |            The series-expansion can be bi-directional. If ``dir=\"+\"``,\n",
      " |            then (x->x0+). If ``dir=\"-\", then (x->x0-). For infinite\n",
      " |            ``x0`` (``oo`` or ``-oo``), the ``dir`` argument is determined\n",
      " |            from the direction of the infinity (i.e., ``dir=\"-\"`` for\n",
      " |            ``oo``).\n",
      " |\n",
      " |      logx : optional\n",
      " |             It is used to replace any log(x) in the returned series with a\n",
      " |             symbolic value rather than evaluating the actual value.\n",
      " |\n",
      " |      cdir : optional\n",
      " |             It stands for complex direction, and indicates the direction\n",
      " |             from which the expansion needs to be evaluated.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import cos, exp, tan\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> cos(x).series()\n",
      " |      1 - x**2/2 + x**4/24 + O(x**6)\n",
      " |      >>> cos(x).series(n=4)\n",
      " |      1 - x**2/2 + O(x**4)\n",
      " |      >>> cos(x).series(x, x0=1, n=2)\n",
      " |      cos(1) - (x - 1)*sin(1) + O((x - 1)**2, (x, 1))\n",
      " |      >>> e = cos(x + exp(y))\n",
      " |      >>> e.series(y, n=2)\n",
      " |      cos(x + 1) - y*sin(x + 1) + O(y**2)\n",
      " |      >>> e.series(x, n=2)\n",
      " |      cos(exp(y)) - x*sin(exp(y)) + O(x**2)\n",
      " |\n",
      " |      If ``n=None`` then a generator of the series terms will be returned.\n",
      " |\n",
      " |      >>> term=cos(x).series(n=None)\n",
      " |      >>> [next(term) for i in range(2)]\n",
      " |      [1, -x**2/2]\n",
      " |\n",
      " |      For ``dir=+`` (default) the series is calculated from the right and\n",
      " |      for ``dir=-`` the series from the left. For smooth functions this\n",
      " |      flag will not alter the results.\n",
      " |\n",
      " |      >>> abs(x).series(dir=\"+\")\n",
      " |      x\n",
      " |      >>> abs(x).series(dir=\"-\")\n",
      " |      -x\n",
      " |      >>> f = tan(x)\n",
      " |      >>> f.series(x, 2, 6, \"+\")\n",
      " |      tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +\n",
      " |      (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +\n",
      " |      5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +\n",
      " |      2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))\n",
      " |\n",
      " |      >>> f.series(x, 2, 3, \"-\")\n",
      " |      tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))\n",
      " |      + O((x - 2)**3, (x, 2))\n",
      " |\n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).series(x, n=8)\n",
      " |      1/x\n",
      " |\n",
      " |      Returns\n",
      " |      =======\n",
      " |\n",
      " |      Expr : Expression\n",
      " |          Series expansion of the expression about x0\n",
      " |\n",
      " |      Raises\n",
      " |      ======\n",
      " |\n",
      " |      TypeError\n",
      " |          If \"n\" and \"x0\" are infinity objects\n",
      " |\n",
      " |      PoleError\n",
      " |          If \"x0\" is an infinity object\n",
      " |\n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import S, I\n",
      " |\n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |\n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |\n",
      " |  taylor_term(self, n, x, *previous_terms)\n",
      " |      General method for the taylor term.\n",
      " |\n",
      " |      This method is slow, because it differentiates n-times. Subclasses can\n",
      " |      redefine it to make it faster by using the \"previous_terms\".\n",
      " |\n",
      " |  together(self, *args, **kwargs)\n",
      " |      See the together function in sympy.polys\n",
      " |\n",
      " |  transpose(self)\n",
      " |\n",
      " |  trigsimp(self, **args)\n",
      " |      See the trigsimp function in sympy.simplify\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.expr.Expr:\n",
      " |\n",
      " |  expr_free_symbols\n",
      " |      Like ``free_symbols``, but returns the free symbols only if\n",
      " |      they are contained in an expression node.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (x + y).expr_free_symbols # doctest: +SKIP\n",
      " |      {x, y}\n",
      " |\n",
      " |      If the expression is contained in a non-expression object, do not return\n",
      " |      the free symbols. Compare:\n",
      " |\n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> t = Tuple(x + y)\n",
      " |      >>> t.expr_free_symbols # doctest: +SKIP\n",
      " |      set()\n",
      " |      >>> t.free_symbols\n",
      " |      {x, y}\n",
      " |\n",
      " |  is_number\n",
      " |      Returns True if ``self`` has no free symbols and no\n",
      " |      undefined functions (AppliedUndef, to be precise). It will be\n",
      " |      faster than ``if not self.free_symbols``, however, since\n",
      " |      ``is_number`` will fail as soon as it hits a free symbol\n",
      " |      or undefined function.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Function, Integral, cos, sin, pi\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> f = Function('f')\n",
      " |\n",
      " |      >>> x.is_number\n",
      " |      False\n",
      " |      >>> f(1).is_number\n",
      " |      False\n",
      " |      >>> (2*x).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, x)).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, (x, 1, 2))).is_number\n",
      " |      True\n",
      " |\n",
      " |      Not all numbers are Numbers in the SymPy sense:\n",
      " |\n",
      " |      >>> pi.is_number, pi.is_Number\n",
      " |      (True, False)\n",
      " |\n",
      " |      If something is a number it should evaluate to a number with\n",
      " |      real and imaginary parts that are Numbers; the result may not\n",
      " |      be comparable, however, since the real and/or imaginary part\n",
      " |      of the result may not have precision.\n",
      " |\n",
      " |      >>> cos(1).is_number and cos(1).is_comparable\n",
      " |      True\n",
      " |\n",
      " |      >>> z = cos(1)**2 + sin(1)**2 - 1\n",
      " |      >>> z.is_number\n",
      " |      True\n",
      " |      >>> z.is_comparable\n",
      " |      False\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      sympy.core.basic.Basic.is_comparable\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.expr.Expr:\n",
      " |\n",
      " |  is_scalar = True\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |\n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |\n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |\n",
      " |      Notes\n",
      " |      =====\n",
      " |\n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |\n",
      " |      References\n",
      " |      ==========\n",
      " |\n",
      " |      from https://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |\n",
      " |  __getnewargs__(self)\n",
      " |\n",
      " |  __getstate__(self)\n",
      " |      Helper for pickle.\n",
      " |\n",
      " |  __hash__(self) -> 'int'\n",
      " |      Return hash(self).\n",
      " |\n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |\n",
      " |      this is the same as:\n",
      " |\n",
      " |      ``a.compare(b) != 0``\n",
      " |\n",
      " |      but faster\n",
      " |\n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |\n",
      " |  __setstate__(self, state)\n",
      " |\n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |\n",
      " |      Notes\n",
      " |      =====\n",
      " |\n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |\n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |\n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |\n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |\n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |\n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |\n",
      " |      The type can be given implicitly, too:\n",
      " |\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |\n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |\n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |\n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |\n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |\n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |\n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |\n",
      " |  copy(self)\n",
      " |\n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |\n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |\n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |\n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |\n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |\n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |\n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |\n",
      " |      >>> u = Dummy('u')\n",
      " |\n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |\n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |\n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |\n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |\n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |\n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |\n",
      " |\n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |\n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |\n",
      " |  has_free(self, *patterns)\n",
      " |      Return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |\n",
      " |      This works for subexpressions and types, too:\n",
      " |\n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |\n",
      " |  has_xfree(self, s: 'set[Basic]')\n",
      " |      Return True if self has any of the patterns in s as a\n",
      " |      free argument, else False. This is like `Basic.has_free`\n",
      " |      but this will only report exact argument matches.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> f(x).has_xfree({f})\n",
      " |      False\n",
      " |      >>> f(x).has_xfree({f(x)})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x + 1})\n",
      " |      True\n",
      " |      >>> f(x + y + 1).has_xfree({x + 1})\n",
      " |      False\n",
      " |\n",
      " |  is_hypergeometric(self, k)\n",
      " |\n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |\n",
      " |      Wild symbols match all.\n",
      " |\n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |\n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |\n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |\n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |\n",
      " |      But they can be identified if desired:\n",
      " |\n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |\n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |\n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |\n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |\n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |\n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |\n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |\n",
      " |      however, you can use:\n",
      " |\n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |\n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |\n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |\n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |\n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |\n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |\n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      Initial setup\n",
      " |\n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |\n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |\n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |\n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |\n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |\n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |\n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |\n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |\n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |\n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |\n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |\n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |\n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |\n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |\n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |\n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |\n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |\n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |\n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |\n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |\n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |\n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |\n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |\n",
      " |      Here, we want `exact=False`:\n",
      " |\n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |\n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |\n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |\n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |\n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |\n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |\n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |\n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |\n",
      " |      Parameters\n",
      " |      ==========\n",
      " |\n",
      " |      args : Expr\n",
      " |          A *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |\n",
      " |      deep : bool, optional\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |\n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |\n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |\n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |\n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |\n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |\n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |\n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |\n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |\n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |\n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |\n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |\n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |\n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |\n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |\n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |\n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |\n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |\n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |\n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |\n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |\n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |\n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |\n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |\n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |\n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |\n",
      " |      rather than\n",
      " |\n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |\n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |\n",
      " |  xreplace lambda rule, **_ from sympy.core.function.FunctionClass.xreplace.<locals>\n",
      " |      # Function needs args so we define a property that returns\n",
      " |      # a function that takes args...and then use that function\n",
      " |      # to return the right value\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |\n",
      " |  __init_subclass__()\n",
      " |      This method is called when a class is subclassed.\n",
      " |\n",
      " |      The default implementation does nothing. It may be\n",
      " |      overridden to extend subclasses.\n",
      " |\n",
      " |  fromiter(args, **assumptions)\n",
      " |      Create a new object from an iterable.\n",
      " |\n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |\n",
      " |  __sympy__\n",
      " |\n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |\n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |\n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |\n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |\n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |\n",
      " |      Notes\n",
      " |      =====\n",
      " |\n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |\n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |\n",
      " |      For example:\n",
      " |\n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |\n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |\n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |\n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |\n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |\n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |\n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |\n",
      " |  is_algebraic\n",
      " |\n",
      " |  is_antihermitian\n",
      " |\n",
      " |  is_commutative\n",
      " |\n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |\n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |\n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |\n",
      " |  is_complex\n",
      " |\n",
      " |  is_composite\n",
      " |\n",
      " |  is_even\n",
      " |\n",
      " |  is_extended_negative\n",
      " |\n",
      " |  is_extended_nonnegative\n",
      " |\n",
      " |  is_extended_nonpositive\n",
      " |\n",
      " |  is_extended_nonzero\n",
      " |\n",
      " |  is_extended_positive\n",
      " |\n",
      " |  is_extended_real\n",
      " |\n",
      " |  is_finite\n",
      " |\n",
      " |  is_hermitian\n",
      " |\n",
      " |  is_imaginary\n",
      " |\n",
      " |  is_infinite\n",
      " |\n",
      " |  is_integer\n",
      " |\n",
      " |  is_irrational\n",
      " |\n",
      " |  is_negative\n",
      " |\n",
      " |  is_noninteger\n",
      " |\n",
      " |  is_nonnegative\n",
      " |\n",
      " |  is_nonpositive\n",
      " |\n",
      " |  is_nonzero\n",
      " |\n",
      " |  is_odd\n",
      " |\n",
      " |  is_polar\n",
      " |\n",
      " |  is_positive\n",
      " |\n",
      " |  is_prime\n",
      " |\n",
      " |  is_rational\n",
      " |\n",
      " |  is_real\n",
      " |\n",
      " |  is_transcendental\n",
      " |\n",
      " |  is_zero\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |\n",
      " |  is_Add = False\n",
      " |\n",
      " |  is_AlgebraicNumber = False\n",
      " |\n",
      " |  is_Atom = False\n",
      " |\n",
      " |  is_Boolean = False\n",
      " |\n",
      " |  is_Derivative = False\n",
      " |\n",
      " |  is_Dummy = False\n",
      " |\n",
      " |  is_Equality = False\n",
      " |\n",
      " |  is_Float = False\n",
      " |\n",
      " |  is_Indexed = False\n",
      " |\n",
      " |  is_Integer = False\n",
      " |\n",
      " |  is_MatAdd = False\n",
      " |\n",
      " |  is_MatMul = False\n",
      " |\n",
      " |  is_Matrix = False\n",
      " |\n",
      " |  is_Mul = False\n",
      " |\n",
      " |  is_Not = False\n",
      " |\n",
      " |  is_Number = False\n",
      " |\n",
      " |  is_NumberSymbol = False\n",
      " |\n",
      " |  is_Order = False\n",
      " |\n",
      " |  is_Piecewise = False\n",
      " |\n",
      " |  is_Point = False\n",
      " |\n",
      " |  is_Poly = False\n",
      " |\n",
      " |  is_Pow = False\n",
      " |\n",
      " |  is_Rational = False\n",
      " |\n",
      " |  is_Relational = False\n",
      " |\n",
      " |  is_Symbol = False\n",
      " |\n",
      " |  is_Vector = False\n",
      " |\n",
      " |  is_Wild = False\n",
      " |\n",
      " |  is_symbol = False\n",
      " |\n",
      " |  kind = UndefinedKind\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |\n",
      " |  __repr__ = __str__(self)\n",
      " |\n",
      " |  __str__(self) from sympy.core._print_helpers.Printable\n",
      " |      Return str(self).\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |\n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |\n",
      " |      Parameters\n",
      " |      ==========\n",
      " |\n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |\n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |\n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |\n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |\n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |\n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |\n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |\n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |\n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |\n",
      " |      Notes\n",
      " |      =====\n",
      " |\n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |\n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |\n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |\n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(binomial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{m^{3}}{2} + \\frac{3 m^{2}}{2} + m \\left(m - 1\\right) - m$"
      ],
      "text/plain": [
       "-m**3/2 + 3*m**2/2 + m*(m - 1) - m"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ff(m,2)-3*binomial(m,3).expand(func=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{0, 1, 4\\right\\}$"
      ],
      "text/plain": [
       "{0, 1, 4}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,m,Integers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{-6, 7\\right\\}$"
      ],
      "text/plain": [
       "{-6, 7}"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(ff(n,2)-42,n,Integers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 35$"
      ],
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binomial(7,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 333300$"
      ],
      "text/plain": [
       "333300"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation(n*(n+1),(n,1,99))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 333300$"
      ],
      "text/plain": [
       "333300"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*binomial(101,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 128032710623051169551167023742976$"
      ],
      "text/plain": [
       "128032710623051169551167023742976"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation((2*n+1)*binomial(100,n),(n,0,100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "128032710623051169551167023742976"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "101*2**100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 54$"
      ],
      "text/plain": [
       "54"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ff(3,1)*ff(3,1)*ff(3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 36$"
      ],
      "text/plain": [
       "36"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ff(2,2)*binomial(3,1)*ff(3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 12$"
      ],
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ff(3,3)*ff(2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 24$"
      ],
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ff(4,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_x=[2,3,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_y=[5,7,9,11]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "lre=LinearRegression(data_x,data_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[12/5, 7/5]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lre.coeffs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7d00dd556dd0>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot((7/S(5)*x+12/5),(x,2,6),axis_center=(2,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_x=[S(82)/10,S(84)/10,S(86)/10,S(88)/10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\left[ \\frac{41}{5}, \\  \\frac{42}{5}, \\  \\frac{43}{5}, \\  \\frac{44}{5}\\right]$"
      ],
      "text/plain": [
       "[41/5, 42/5, 43/5, 44/5]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_y=[S(84),S(83),S(78),S(75)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\left[ 84, \\  83, \\  78, \\  75\\right]$"
      ],
      "text/plain": [
       "[84, 83, 78, 75]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHkAAAAUCAYAAACpkJLNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAADq0lEQVR4nO2aXYhWRRjHf6sWeRFFSQVdiEHQxUrbRZmC7oZFhBCuuTdR6U0QBGIfFJT5929EetHXVV0E7k0XUV6VkhC52kUhFEUftFGxRZQfmx8YFpauFzNvHU/n3fecs7O9Z2V/8DLvmTnzPDP/Z+a8c2benomJCWa5sJnT7QbMMv3Ma32xPQDszZSNSrrh/27QLPWwvQA4ks2T1AOZIGfYB4wA4xkDVwKDwCpgMXAtcBr4AtgB7JB0tsDxWqAf6ANuBC4F3pB0X4lGLwc2AsuAK4Cj0d/LknZ3qt806mpRQYdTgOP39cDCVkFRkEckbcnlDQGvAr8SZvtPwNXAGuB14C7bQ5LyP/CbYod+B34GSj0ZbG8CniUMtHej3wXATcAAMOOCTA0tqugg6RSwJdYboEOQi/gWuBvYlZ2xtp8CDgD3EAK+M1fvkdih7wijeC8dsD0UO/Y+sEbSyVz5RSXb3DQqaZFSh1JBlvRBm/yDtl8DniOMrJ258n86YptO2J4DbCc8eu7Ndyza/KtMm5tGFS1S61B2Jk9Gy9nfCWwtAxYBbwPHbK8CeoE/gQOSPkrgYyaQVIcpBdn2POCBePneVGxFbo7pIeBTwiIv628/sFbSkXzFC4ykOkz1PXkbYYTtlrRnirYArorpQ8B84HbCKrQX2AOsAN5K4KfpJNWh9ky2vQF4DPgGuL+unRxzY9pDGKmfx+uvbA8SFoD9tpdO56Pb9hiZ1WkJSr0WViCpDrVmsu2HgVeAr4HbJB2tY6eAYzH9IdMxACT9QRjFALck8teO74HRCp9fEvtPqkPlmWx7I/AS8CWwUtLhqjYmYTSmx9uUtzo/P6HP/yBp5XTaL0FSHSrNZNtPEgL8GWEGpwwwwH7CKv162xcXlPfGdCyx36aRVIfSQbb9DGGh9QlhBo93qFKZaPNN4DJgc87/HcCdwAkyK3nbw7YnbK9P3Z5uUUeHySj1uLa9DtgKnAE+BDYUvNCPSRrO1VsNrI6X18R0qe3WfeOSHs/ZeRRYAjxtewVhR20hYe/8DPCgpOOZ+1sDNcV7+rRRQ4uqOrSl7G/yopjOJWyWF7EPGM7l9QHrcnnXxQ/Aj8B5QZZ02PYSwl7vIHArcBLYBTwv6eOcvcWZ8ibTRwUtaujQlp7WnwYyR40uOKBoJLYvB34DXpD0RJeb0xhsjwD9kx01yraYGefJywnbqi92uyHdpug8uUU2yGP8ex4JmfPkpiLpHeCSbrejIWTPk8/jHKQ4learzGOjAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle \\left[ 216, \\  -16\\right]$"
      ],
      "text/plain": [
       "[216, -16]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LinearRegression(data_x,data_y).coeffs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIUAAAAUCAYAAACj4P7aAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAEcklEQVR4nO2abWiVZRjHf1OL/BBFWQl9EKOgYOb6UKY0t7AlJZRT96HIFCowCjN7s5r99++FJr0t+lBQ4CL6UGkQqbSK3BIspKIoo0XGipGmyxcMC2utD/dz7PHpbOc5zzlz58B+cLjPue/zXNd9/lznul9rhoaGGGecOBPGugPjVB6Tcm9sNwJbY229ki480R0a58RgewqwL14nqQZiQRGjB+gGBmIGzgSagQXADOBc4CjwNbAeWC/pnzyOlwANQB0wEzgVeF3STSk6XQ+sAuYAZwD7I38dkrYUer7SyKrFKOpwBHD0fjkwLdeQLyi6JbUl6lqAF4HdhGzyM3AOsAh4BbjGdouk5ASllSDA70A/kCrz2G4FHiME5qbI7xTgEqARqLqgIIMWo6mDpCNAW+SnkQJBkY/vgeuAzfGMYPshYAewmBAgGxPP3U0Q4AfCv2QrBbDdQhDiQ2CRpMOJ9pNS9rnSKEqLsdQhVVBI+miY+j22XwKeIETuxkT7sR9um0LYngCsI6S2G5NCRDb/StPnSqMYLbLqYPt9oAlYLOntWH0NYZhfBqyTtGYk/2kzxUjkOvd3GWzNAaYDG4ADthcAtcCfwA5Jn5TBRzWQVYf7gC+Ax22/I2kwqn+aEBAvFwoIKHFJansScHP08b1SbEVcGpW/En7cJqAd6AC22+6xfVYZ/FQ6mXSQ9BXwGnARsBSODfGrgTeBFWmcl7pP0U6I4C2Sukq0BXB2VK4AJgNXEWbptUAXMBd4qwx+Kp1SdGglZJQ223cShvYuYGm+FWI+Mg8ftlcC9wDfEUVlGZgYlTXAkijyAXbabiZMeBtszx7NocR2H7HZeApSLbOLILMOkvptdwBrgBeA7YSJ6tG0zjNlCtt3AM8D3wJXStqfxU4eDkTljzEhAJD0ByHiAS4rk7/h2AX0FvH6pcz+S9Uhvil1S7T8TE3RmcL2KuA54BtgnqS9xdoYgd6oPDhMe06syWX0+T8kzRtN+ynIrIPtGwgTyz3AVOAu4PZinBeVKWw/QAiILwkZopwBAfAxYRVzge2T87TXRmVfmf1WGpl0sH0t8CqwE7iYMLTfaruo44rUQWF7LWFi+TkhQwwUeKRoIptvAKcBjyT8NwHzgUPEVjq2O20P2V5e7v6MFRl1uIKwhO0Hrpa0D1hLGA3ai/GfaviwvQx4FBgEtgEr82zA9EnqTDy3EFgYfZwalbNt5743IOnehJ3VwCzgYdtzCTum0whnL4PAbZIOxr6fC+xy7JOMGhm0SK2D7ZmEZeshoEnSbgBJG2x/Blxvu17StjR9TTunmB6VEwmHM/noAToTdXWETZM450UvgJ+A44JC0l7bswhLq2bgcuAwsBl4UtKnCXszYu2VTB1FaJFWB9vnEyaeQ8B8SbsSPh4EPgCeimwUpCZ3ySZ2dO48B2IVie3Tgd+AZyTdP8bdqVpsdwMNIx2dy7aojvsU9YRt9mfHuiPVRr77FDniQdHHf+frELtPUalIehc4Zaz7UaXE71Mcx7+7gvBwFVynugAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle \\left[ 216, \\  - 16 x\\right]$"
      ],
      "text/plain": [
       "[216, -16⋅x]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Data([1,x])*_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGUAAAAQCAYAAAAPk7G9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAADl0lEQVR4nO3YW4hWVRQH8N/oFPgQUZEJPZRhUGDpQ2WJqWEmJITj5aHIfKgHIyu7kYW2WlRkVGTUm4FG9JBdIErRCsIkK6MoupCRYmBRJpoIGaZND/vMcJzm05nvmxnmwT8c1j5nX9b6s/baa+3T1tnZ6SSGF9q7Gpl5FjowG5fgXBzGN1iDNRHxb31yZs7HNEzEBJyGVyPi5hMpzsyrsRSTcSb2VbpWRcSGFnn1C8ONx4haewFWYxI+wyq8ifF4Cesys63H/OVYUpH5pa9KM3M5PsJUbMSzeAdnYHq/WbSOYcWjvdb+ETdgfT0iMvNhbMM8zFUc1YV7sBs/KTvtwz4QWYDH8AHmRsTBHv2nNMWkNQwrHm19ySmVY57AixFxZ4Mx0xUyDcM+M0coxM/B+RHxR3NmDx4Gk0dmvoeZmBcRb9W+tykpYhGeam8wvyf+qeSRPo5vhMkYizewPzNnK8fj39gWEZ+0uP5QoVkeD+BLPJ6Zb0fE0er7M4pDVkfEshENJncjM9txS/W6sXke4PJK/l4Z9y5WKvlra2ZuzsyzW9QxFGiKR0R8jVdwMRbSfQrdi3VYzLGJvhFWKrtgQ0RsaoUJRldyMUbhWqXSGY9NSsJ8vUUdQ4FWeCxXIurRzFyipIVNWNiVy497fGXmXbgPP6g82yJGVrIN86udA99lZodSbEzLzKuOd5Rl5i6c1w+9fSpv+4GmeUTE7sxchWV4AVuVQuFw15iGkZKZd+B5fI9rImLfAJDZX8mdNSJdxh5SdgxccYJ1dmB7P55fB8D2OlrlUS8Mbo2Iv+qdvUZKZi7Fc/gWMyJiTz+NboTtlfyzQX8X2VHHWyQiZgyQPc2iaR6ZeaOS2H/DGNyN2+tj/hcpmfmg4pCvlAgZKIdQLlpHcGFmntpL//hK7hpAnYOBpnhk5vV4Gd/hUiUt3JaZF9XHjegxaYWS2L9QImTvABDoRrXeazgdj/TQPROzcEDrVd6gohkemTlFKaF347rqbrNCOa1W1tfovjxm5iKsxVElAR3oxZ5dEbG2pmgO5lSvYypjdmJL9W1vRNzfw+jR+BjjqnHblKTdgU7cFBFDWoENNo/MnIDNOIQpEbGjts7nuAxTI2ILx+aUsZUcqfxg6w2bFcd1YaJy6anjguqBn3EMmYjYk5mTlNKwA1fiINbjyYj4tIHuwcREg8QjM8cpib8Ts+oOqfAQ3sfT1Rp9+81yEkOL/wDWkaWxtaWnHAAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle 216 - 16 x$"
      ],
      "text/plain": [
       "216 - 16⋅x"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAC0AAAAQCAYAAACC/vbpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAACvklEQVR4nNXW3YvWVRDA8c+aFRIRlYYQESpBxVZaqGn4UhiLFaWy3kTQldVFZKmkoDRMXRlk+h/sRV5EQtKLGGXCRkULCREZUSyBSVq+hbGJvWwX56z8np8m8eheOPAwzzMz55zvb35nZp6e0dFRl5pMbBsy82Gsxu24Hj/jS2yJiM9bsf1YhJm4C1dje0Q80S1QZi7A85iP63AMX2NrROyCCa0Fm/Ee7sZubMM+PIZPM7MNswnPVuiD3YI2zt+EQSys57+Gd3EtFo/FTWwsmIp1OIw7I+KXhu9+fIyX8UbjnBfwE35QMr73AoBX4hV8hBURcbLlv/wsaNysZP6LJjBExN7MPIkpbXtj0255ZeYEbMYIHm8D17P+PBf09ziNOZk5OSKONDZdqNzXnV2TnV/mYxp24Hitq16cwlC7ls5AR8SxzFyPLdifmTtxFDPwKD7E0+MEPbvqw0oN3dF0ZuYg+iPiV1qFGBFbsUJ5mFXYgJU4gIH2tbmIckPVz2ASlihvthcfKIX51lhwu3u8qLyiASXDV+EeDGN7Zr46TtCXVd2jZHRPRPweEd9guVLsizJzXgd0Zi5WiuGdiFgTEcMRMRIR++rCg1ibmdPHAfp41cMR8VXTERF/KNmGOR3QeKTqs9pWRIxgqMbPupi0Vb6r+sR/+MceahKd0FdW3dHWGjJmP90t2XlkEH/hlsy84hz+3qp/pBP6k6qfyswbmysycynuU1rQZxdCl5kzMvPW5rCo7fVNXIOXWvEPog+/KVOyo0/vUKbREnybmW/jEG5Trk4PNkTE0caGy7Cs/pxa9bzMHKjfj0TEuhb3HmWQTVMzV2UN5mJjnQtDNW45/saqiDhBI9MR8Q8eUkbz/hq8FvdiF/oiYlsLYCaerJ++apvesPX7n1Lb6Vy8jpvwHB7A+1gQEWdaXs+l+Nf0Xy/g8G7Um4bpAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle 81.6$"
      ],
      "text/plain": [
       "81.6000000000000"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.subs(x,8.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADoAAAAQCAYAAABHjGx4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAADV0lEQVR4nOXWTaiVZRAH8N9VCyTMSrgFBfmR1sLIRWUZpfZhkRBquolK2gmWGQVBWMMUUpvKUtoUKEGLsqAIRSWJjNIEo+jbUm5gVGZamBh93RbPc+x47j363nBVfzjMOWfmnZn/M887Mz39/f3+DxjR+pKZYzAXs3EhzsZv+AirsToi/mp/ODPnYzqm4CKMwgsRcevxAmfmlViKaTgD+2usFRGxvimBzDwHD+MGjMG3eBUZEQdadsPanlmAZzEV72EFXsFkPIeXMrOnI84y3FmJfjOE5JZhC67CBjyO13E6ZgzBzwTswB3YjiexG3djay0e2iqKnbgJ69orl5kPVCc3Y55CvoV7sAdfKZV9s0FyC/AI3sC8iDjYoT+pKVE8g14siYiVbT6eqLktxyLoafKOVrLLsSoi7upiM0Mh2vXqZuYw5VDOxNiI+KExpYG+xmMX+jChozijlCvcg96IODRiUC8D8XuVf/zbxCqmYRxexoHMnK28Gr9ie0RsHYKvq6vc1Nk7IuJgZr6DWbgMm49LNDNH4Pb6c8MQEhkMl1T5Pd5Xml57rC2Y37DS51e5s4v+S4XoJGwe1sWoHY8pp74+IjY2sD8WeqtchJG4VunUk7FRaU5rG/oaXeXPXfSt/0/j6K47AJm5BPfic9zWMIFjYXiVPUrlNkfELxHxiTLa9mB6Zl5+AmK1JkQ/xyCamYvxFD7FzIjYfwKCt+ba7oj4sF0REYeVqsKlDXy1Kja6i/7UdrtBiWbmUqzCxwrJ7xoEboIvqvypi751ECOH4GtSF/3EKncyCNHMvF8ZvB8oJPc2CNoUW5TOPTEzTx5EP7nKvga+WjN7Vh1bR1DHyxU4jG10EM3MB5XmswPXRMS+hgQaofp7UbluD3XEvg7XK1dtQ4duQmZe0L5MRMQubMJYLO4IlTgFz0fEIdoWhsxciDX4EysN3s36ImJNWwJzMKf+PKsmuhtv1//2RcR9HUn34h2cV+2241ylGfXjlohY2/FMX7UZFxF97QeAd5Vu/ho+U1bYmcqVnRYRP3L0CjiuyuHKsj0Y3lIOo4UpWNhhM75+4GscRTQi9mbmVGVPnqsM9INYh0cjYluX2AMQEbsy82L/LPU3KhvR08pSf6SBNloB/wv4G3oMJvdqIDduAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle 216.0$"
      ],
      "text/plain": [
       "216.0"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "81.6+16*8.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAC0AAAASCAYAAADPNlfiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAACeklEQVR4nNXWTahVVRQH8N/zSRgUFg0MapKjEkUnQol9WBCFlF7tOdJslINAFIMoisUKimYRFH2Q+CY6S3HgRwg+UjAIBMUIB4H2qYkKgoGYvufg7Au3+845N/Qm+IfDOnvvtf/rf9bZa+89MjU15U7DzN5GZr6Cp7EIC3EvtkfE2v6Jmfkatg3gn4yI0bqBzJyDP/EZEh0sxwI8hKs4UWJsi4jJWtF4t4i9jN/xaIugYyVYHZ7Es9jXMn8FZmAXxvA5zmACv2IOVuFrvJiZYxExVSd6cxH7syrjE00RI+JYET4Nmfl9ef2qRXQHF3AII3gZe3ozmpnv4AesLh/wzTTRETHRM6ElXjMycz4exx/Y0+AzW/UndkTEdRys84uIs5n5BT7AM13RM25KWTs2FLu1CKrDctyFnf+B759ir3U7hio6M+/GWkyq1mITOvgbBwbwzcSrpbm/2z/sTK/BfdgXEb81CJmFF4rPlQF8H2E+9kbEt93OYYt+vdgvW3yexz2qXaMRmbkRW3AS63rHhiY6M+dhiWr32dvi2lHtwbVFWrjewCf4Ccsi4mLv+DAzPbAAM3MUL+FgRFxq8NmET/GjSvDZfp+hiC7rdJ2qALe2uD6FBzQsjcx8Cx+r9v9lEXGuzm9YmR7D/aqCqS3AglWqD9vdP5CZ76kK7yiei4jzTST9d4+VWFmaDxb7RGaOl/fzEfFmDU+3ANtOQIX7SET81Rd3Pd7HdRzGxprD7XREjE8Trboore/rm1se+AX/Ep2Zj2GpAQWYmYvxsOr39+ORYkexqYHiO4zDyO26mmbmh3gbcyPi1K1w/R/HeBM6OH6rgrmNmR4mbgCp18nmL9a1ywAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle \\frac{17}{2}$"
      ],
      "text/plain": [
       "17/2"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data_x)/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_x=Data(range(3,7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHYAAAAUCAYAAABYm8lAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAEcklEQVR4nO2ZW4hWVRiGn5nsIGMHSlQCswOGohJFmYrOiJUF2oWWN1aokCFdRIcpOlivLxGMlGXkRUe0w00HUihNSRgdosALIytBIQ91oTOeJjS1NKaLtX5ms/1/3f/8e89UzAvDt/das9537fX969vf/lZdV1cX/fj/ob6vJ9CPYjCgdGF7KtCa6NshaVRvT6gf2WB7MHAg2SaprnQ94IwRsBnYBBxMES0FbgauBwYDJ4C9wBpghaRDOc67Imw/AHwQbxdKercAjT3AiArd7ZKG5a2Z0p8CPApMAi4HDgM/AsslrYv/dhxwvJ5Par7lHLtJ0pIy7Y8BW4GvgQ6gAZgALAEesj1B0m89fpoMsD0ceAM4BgwqUgv4HVhepv1YkaK2FwMvEjbWl8A+wka6EZgKrAOQdJyw9qVoe07HVsIlkk6WmchLwLPAM8DD1TxENbBdB6wEDgGfA81FaUV0VviBFwbbcwhO3QjMlnQ01X9+Vq7MyVM5p0Z8Eu3IrFw9xCPANGAB8EfBWr0O2/XAUkKInZt2KoCkU1n5qtmxlXB3tNty4CoL26OBFuB1SW22pxWllcCFtu8HriL8kLYBbZL+LkhvEnAN8BlwxPYMYCxwEtgi6btqyKp2rO1mwvvtUkIyNZnw0C3VcmXUGwB8CPxKCPm9hWFRN4ndthdI2lyA3i3RthNymXHJTtttwL2SDqQHlkNPvmObARGytsnAemB6VsEe4AVC4jBf0omCNNJYCdxGcG4DYZHfAq4GvrJ9QwGaQ6JdBAwEbgcuJuzaDUAj8GlWsqp3bCnVtz2UED5agO9tz5S0tVq+s8H2eMIuXVZtKKoFkpxq+glYZPsY8AQhG52Vs+x50dYRduYP8f5n27OAnUCT7YlZ1qLHlSdJ7ZJWA9OBK+j+tswFiRC8E3g+T+4a8Ga0jQVwH4l2V8KpAMRItSHejs9CVnNJUdJeYDswJlZD8sIgQjFkNHDSdlfpj/AqAHgnti3PUfds6Ii2oQDuHdF2VugvOX5gFrI8smKAK6PNM2P8E3ivQt9NhPfuN4QF6a0wPTHaXQVwtwGngZG2L5D0V6p/bLR7spBlcqztUYQP9v2p9nrCB/UQ4FtJR1L9q4B5wAJJq7JolRDDz4MV5rOE4Nj30yXFWjTj+DHAPkmHU+0jgBXx9qMy42rSlXTQ9sfAfYSEcXGC+w7gTkI1bH0Wvqw79i7g5Zhy/0Ko/gwFmoBrgf3AwjLjSqH+dEadPFCr5hzgadutwG7gKHAdMAO4iFDSe6UAXYDHgVuB52w3AlsIpcJZhGi4UFJnFqKs79iNwNuEJGk28CRwD6E4bWCMpO1lxo0jLMzajDp5oFbNVmA1oVgwl7DYTYSwPw+YWSZM5qGLpA6CY18DhtNdbVsLTJGU+XOnrnTQnji2cx41UtuXEXb2MklP1cr3b9XsS92E/iag6VzHdrItaj+PnQKcAl6tgeO/oNknuuXOY5NIOnYP3ed7kDqPrRaSviC8k3oNfaHZh7rJ89gz8A91r42vIjhFKwAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle \\left[ 3, \\  4, \\  5, \\  6\\right]$"
      ],
      "text/plain": [
       "[3, 4, 5, 6]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_y=Data([2.5,3,4,4.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJsAAAAUCAYAAACah0+BAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAElUlEQVR4nO2aa4hVVRiGn7GJgpESHBopykwqo8SKCO2mKUnRBSrmX6ZCRhQMEw1dBHvnLYSJsrKELA2n7FfQBcJLdJlLURBkYSEpmKP9cLyVkallNv1Y++TpzD4zZ5+z9zmm8/xZZ69z1veutb/vfGvttVfdwMAAI4xQDUbVugMjnDzU5z7YngF05X23WdKkandohP8/thuBPfl1kurqY37bA3QDe/MajwXuBG4FJgPnAH8C3wGrgFWS/k7QmT5gfJGvd0kaV6qtJNh+BrgKuAhoBA4B24H3gWWS9mWhW9CHOcCb0eUCSSuz1qxUtwx/HQQcfZ6XaxsXbN2S2gvqmoFXgJ2E7LcDaALuAlYCt9hulpRkAfgr8GJM/YEENpLyMLAB+AjYDTQAU4F24H7bUyX9lJW47XOBlwljHJ2VTka6JftL0kHCPc3NmEWDLY4twB3AmvwMZnsh8BVwNyHw3inRHsD+mKDOmjMkHS6stL0YWAg8ATyYhbDtOsIssA94F2jLQidD3Yr9VVKwSfq0SH2/7eXAYmAGyYKt6sQFWsTbhGC7MEP5FmAm4T7NzFDneNEdRKmZbSiOROVfCdudZvse4Dzgd2Aj0CvpaAp9SsrtUbkxC+O2LwE6gKWSem1Xxekp61bsr4qCzXY9cG90uT5h83HA6oK6bbbnS+qppF/DYbuNsHY5k/DAcB3h5nVkoFVPGOcOQvasChnoVuyvSvfZOoDLgLWSPkzQbhUwizCABsIT7qvA+cA621Mq7NdwtAECWgmBth6YLWnPUI3K5EngCmCepEMZ2K+Gbir+Kjuz2W4BHgF+AOYkaSvJBVXfAw/YPhDZbCdstWRC7lHddhNwDeFP843t2yRtSEvH9tWErLJE0pdp2a22blr+Kiuz2X4IWApsAm6U9HM5dmJYHpU3pGRvSCTtkvQeMBsYy7F9qIrJm8a2AIvSsnuc6SbyV+LMZrsVeIEQ3bMk7U5qYwhythpStDkskrbb3gRcbrtR0t5hGw3PaMLmMcBhuzA5ALDC9grCAr41Bc1q6ybyV6Jgs/0YYcr5FrgpJafkMy0qf0zZbimcHZVpPQ3/Abxe5LsrCeupz4HNQJpTbDV1E/mr5GCzvQh4CviasJgeduq0PRE4Fdgq6UhUdymws7C97fHAsujyrRhbncBcYL6kzlL7ndd+EmFjsr+gfhTwNHAW8IWkX9LQjRbl9xXpSzvB6W/EvTaqZKwV6qbmrzhKCjbbcwmBdhT4DGiJSc99MTfmE8KriglAX1TXDDxuuwvYBvwGTCS8dz0dWAs8F9ON3Poy6X5ejpuBZ233AlsJO+pNwHTgAqAfWJCBbjnUQhPS9dcgSs1sE6LyFMJ2QRw9QGcJtrqAiwn/sGmE+X4/IbWvBlYXecc6mTDQNSX2uZCPgdeAa4EpwBjC5uSWSPelItm6Ut1yqIVmMcr11yDqcocn844YuQbvLIfE9hhCJloi6dETWbdWY80K293A9GJHjGRbHF/n2a4nvBZ7/iTQrdVYUyPuPBv8dxrt49gZJMg7z1ZrJH1AWB+c8Lq1GmvK5J9n+5d/AGMW+bk2BLnSAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle \\left[ 2.5, \\  3, \\  4, \\  4.5\\right]$"
      ],
      "text/plain": [
       "[2.5, 3, 4, 4.5]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANgAAAAUCAYAAADvCvMiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAEi0lEQVR4nO2bbYgVVRjHf1sbBYspGCUUmUovUOIGUYnUugmLFYRWftOsLyEJm2FU9MLjPwj6UGbai0KwC9bHoAitBL1rb0QQREX5krVFoJmW4mqQ2fbhnLvenZ2ze+fuzszdZv6wPHfOyzP///KcM+fMPKdlcHCQEiVKpINz8iZQosT/Ga3VH5IWApWaur1mdk3WhEqUmIyQdBHwe22ZmbW0xrTdDfQBRyIO7gU6gHZgHjAFeMvMljdAph+YGaj+zcxmJPWZ4N6XAc8Ci4HpwEHgHUBm9mcd/acDS4E7gbnApcDfwDdAD9BjZv/G9OsnB81F0ptzjJ4C5H/fX+0bN8D6zGxdTPnTONIDwK/AeJ9ux4ENMeUD4/QbhKQ5wGfAxcC7wB7gRuBhYLGkBWZ2dAw3y4DXcYFaAX4BLgHuBt4Abpe0zMziNreZai6aXnKMUTM7BayDodVgcICF8AiO9A+4WaIyevMxcSwwkNPEa7hg6zazTdVCSetx+p4DVo3hYx9wF7CtduaW9CTwBXAPLvjejumbteai6W26GK17gJnZEFlJozVtSkiaDXQB/cCrkWoDHgRWSFprZidDfsxsV6D8kKTNuKBdSHzAZYai6YXmjNEkT7CJxvmSlgOXAyeBr4GPzOxMSve7zdsd0T2DmZ2Q9CkuIG8GdjZ4j9Pe/hOoz1Jz0fSmgXHzz/M1/QxgK24G3ADsAvZL6kjpfld7uy9Qv9/bqxpxLqkVuM9ffhBolqXmoulNA+Pmn9cA6wEW4QS04d5ObQGuAN6XNC+Fe0719nigvlo+rUH/zwPXAdvN7MOY+qw1F03vRGNC+OeyRDSz6AL5W2CVpAFgLe5tzNKMabV4mzi1RVI3jvceYEVcmybUXDS9iTBR/Jstk2Ozt7em4Ls6Y08N1F8YaVcXJK0GXga+AzrN7I+EvNLSXDS9WSER/2YbYIe9bUvB915vQ3uOK70N7VlGQNIa4BXc7NZpZoca4JWW5qLpzQqJ+DfbAJvv7Y8p+K6+wu2SNEy3pCnAAuAv4PN6nEl6HHgJ+AoXbIdH7xFEWpqLpjcrJOKf6h7MZxKcBxwws9O+7FrgYHRpIWkmbnYEeDPGVy+wEnjAzHqTcjGzA5J24F5NrwY21VQLNyNtiX4TCmh4Bpd+9CXQNdYyqRHNpd5sMJExGoe6B5ikJcASf1nNw5rv/zEAR8zs0Ui3nbiUkVm4D57gUm+ekFQBfgJOAHNwuW4XANuBF2IoVGfh0DeXevAQLnVoo6RFwPfATUAnbqn0VEyfYRokrcQF2xngY6A75qNmfyRIGtFc6k2IJojREUjyBGvHzTC1mO3/AH4GouTjUMF9o7ke97htA44Bn+C+OWwN5LXNxQndloDzMPhZ/QbOJr/egcux24hLfq1nwz7L23OBNYE2u4HemutGNJd6k6OdfGN0BFqqBy5rjqsohxzBUSFpGnAUeNHMHsuZTuoo9U5uSOoDOkLHVUyS0VznwW7BpeWsz5tIRij1TjLEnQeD4UvEfs6eZ4HIebA8YWbv4da+hUCpd1Ki9jzYEP4DxOPZ1qd5Da8AAAAASUVORK5CYII=",
      "text/latex": [
       "$\\displaystyle \\left[ 1.5, \\  0.25, \\  0.25, \\  1.5\\right]$"
      ],
      "text/plain": [
       "[1.5, 0.25, 0.25, 1.5]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_x.centerise*data_y.centerise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACEAAAAQCAYAAACYwhZnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAB70lEQVR4nMXVTYjNYRTH8c9MRF1vRWayMJi8lDQpi/ESCzUpLCzsbCxYWJFZYHOcpMgspFlgo4yVjVmh0GSS5SwsLNSYmSy8hRGipLG4/9HtunNnblP8Nqfze57n9H1O//P8myYmJvxvzalMMvMitmAdluE7xtCP3oj4MNPCmTmKtimW30ZEa00InMAQHuAdSujEWRzNzM6IeDVTEHzG5Rr+18qkGmJRRPyoPpGZ53EGp3GsAYjxiDg73abmyqQWQKHbRVzbAMCMVd2JqbS/iM8arD8vMw9hJb4V5wcj4te0EJnZjQVYrPyh7igKXGgQohV9Vd5IZh6OiMeTRrPa6kbgeAFwH10R8b4BgBvYXYCUsAnXsAr3MrNjcmNTvXciM1uwTbkDC7EvIoYaAKlVswcn0R8RB5i6EyAi3kbEHXRhKW7OBqDQ1SLunDTqQlTAjOE5NmbmsllCvCtiqSGIQiuK+Kvurum1tYgvJ40/05GZG5QflzeVJzKzGeewHE8j4lPFWjvmYjgiflb4G/E6Ij5W1WpDb5He+gsCe3ApMwcxjA9owS6swRscqbrVI+X/w2qMVvgHcSozBzCCL2jHXszHXfTUgniI69iODixRfmBeKM/6leqb1dEA1mOzcvtLGMeTolZfRPwZy7oj+q/0Gyq7lMX78YeKAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle 3.5$"
      ],
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACEAAAAQCAYAAACYwhZnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAB7ElEQVR4nM3VT4gNUBTH8c+IqMmfKFnIv8mfkmyEaYpQmmJjYSOyFUXYKIvjKDtpGn9iRdhjQ00xJWQt5V+YnSgxIaV4Fu++eu/Ne3qvFGfz697z69zvPfd2b0+lUvGvY3L9IDPHsLCN931EzOumeGbOx0kMYg7e4SYyIj61hCgxjqEW81+7BOjDI8zFLTzHWhzCYGYORMTHdhCfI+JENwu2iQsF4GBEnK2DO4PDOIV9MOkvLDYhMnMJtmIM55vSgW/Yk5m9tO7E1MzcjQXF/AT3I+JnFxybi45ExK8GgogvmfmwQK7H3VadmIdrqu0awj28ysyNXUAsL/qyTf5V0WVMPI7L2FJAerEKl7AIdzJzdYcQM4uOt8nX5mfRdBwRkU3mp9iXmV9xFCewo0OQP0VP0QqdX8yLRTd06K/tdGab/Ix6X6cQH4r2duh/UXRZm/zSoi+7gegv+qZD/2jRrZnZsEZmTscAvuNxA0RmrszM2c3VMnMhzpXh9aZcX2auyMwp9fMR8Rojqhf6QHNJ1Y5ejYhvNF7MnTiWmaN4iy/owzZMw22cbip4V/WvWaz6MNXHftVnezgzt+AZ1mGT6jEcrxnrWzWKG6XgLhzBRjzAXmyPiB86jNKNNbhSFj9aNjWM/tq/AT3/w1f+G8Zzj2HUEHrjAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle 5.0$"
      ],
      "text/plain": [
       "5.00000000000000"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data_x.centerise**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACEAAAAQCAYAAACYwhZnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAB30lEQVR4nM3VTYiPURTH8Q9G1CwtTClDs7BAsrTBpJSUQrPzslVqUhakdBylLJRRyig1U2NrabAwk5eVUkISYbKZMQuRsTHGWDzPX495f6I4m/Pcc3/39L3n3ueeRZOTk/61NTU+MnMF9mI3NmIVvuEZetATET8Wmjgzh9A6y/SHiGiZBoEOXMEwBvEeK7EP17ArMzsiok7pPqNrhvhYdVCFeIU9uFndcWaewiPsL4Fu1ID4FBFn5hP9goiIgZkEETGSmd04h+01IRZkTfNLwHjpv9fMvywzD2A1vuIp7kfERFW0eL4smdmEQ+Xwdk2IFvQpqtiFAbzOzG21IHAeG9AfEXdqAPRgRwnSrPjjrmINbmXmpoZwzuPIzE4cx0scrAEgInJK6DmOZOZYmfOM4kmYvRKZeRSX8ALtEfGxDsQc1l36rY3AjBCZeQyXFfTtETHylwBgtPTNs0Jk5glcxJMSYHSq5g9tS+nfNgK/3YnMPI2zeIyd8x1BZrZhKd5ExHglvh7DU9dnZquiwnB9GkRmHi4BJvAAnZlT75ahiOitjO8q+sNaDFXiHTiZmYN4hy9oU/Sl5ejHhWkQZSJYgmMz79099M4yV7VBrMNmRfmb8QkPFe9GX7UHLfofWvlPRMCXljs57M4AAAAASUVORK5CYII=",
      "text/latex": [
       "$\\displaystyle 2.5$"
      ],
      "text/plain": [
       "2.50000000000000"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data_y.centerise**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAD0AAAAZCAYAAACCXybJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAADe0lEQVR4nOXYW6gVZRQH8N/xGFSHspJ6KSgT7YK9BWX1oAknu1BUGARZ9lKRYIYPQSGLFQU9dbEL3UTpMQgy8ZKQIVFWIAhFF6MQMpLoQpkFpsceZnbNGWfO3rs25cE/DGtmvnXd3/rWrLWHDh8+7FjD1P/bgV6QmSfhl0HpmxRB4yosjIg3B6FsyiCU/AeYh7cHpeyoDzozhzEcEQcGpfOoDxqX4b1BKpwMQV+DjYNUOBmCnh4RPwxS4RHVOzPPwsNYiOn4Fq8jI+KniZRl5hKs6WJzLCKGe3EuM2fh85a16bgR1+IinIkD+Kj0YU1EjDXJjtvpzJyJHbgTH+IJfIX7sL00NBF2IluurSXPpi46qrge61vWFuElXIIP8CRewxy8jFczc6hJsL7Tz+EMLIuIpzsvM/Nx3I9HcU+bhxGxUxH4EcjM7eXti23yDZgdEbta1nYpfpQN1R3NzAcVG3YzblL8EOMwpcJ8LkaxG8/W+AL7sTgzR/pwuqN7Di7FN9hQW5uSmY9k5tW196eh9SxHxNaIWF9P4YjYi+fLx3lNstX0vrKkWxoU7cO7OLF0vl/cXdLVEXGotjaKuYp0reLfVO0/SnqwabEa9HklbUunL0o6ux/rmXkCbsOY4qyNQ0Rsxgpcl5lVf+b6B9/nzJyK28vHzU08VSPTSvpzi77O+1P69OOWUmZTRHzdxFDWgt8UjYjMPA6H2qpvFzymKGYb23r1fr7TnUrY7yx6V0lf6ML3Bm4o7+dhW592ZOYyRdZ8hsVtfNWgOzs5rYkRJ9f4enHiQsXu7dH9fK7zd9Cj6GuiysyleAqfYH5E/NjGWw260wS0ndlZJW07802YqIDVsQ2nZ+YFGImIX3s1kpnL8Qw+VgS8dyL+atCd0W20VlA6Q/zl+B3v9+jI8YoUG8PqbvwRcVCRDSsVXVVPyMwHFE3UTkXA33WT+Su4iPgSW3AOltZ1YwSvRMT+isGZmXl+WXjqWIRTFQWlsYA1YB1u1d6FjXcqc6WicO3Agoj4vhe5ekd2r+IzsSozF+BTRZs3X5HWD9X438LZmKFoaqroFLB+OrBN2B4Re7oxZuYdihnhEN7Bssyss+2OiLX1l+PSuNzti7FWEewKzMQqzO112inP5RV6K2BV+/sUA0QvmFHSYSxXdI31a0mT4NCx+G/oZJinB45jMug/AS8lGNKZ5BEeAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle 0.7 \\sqrt{2}$"
      ],
      "text/plain": [
       "0.7⋅√2"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.5/sqrt(50/S(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 0.989949493661167$"
      ],
      "text/plain": [
       "0.989949493661167"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\left[ 0.424264068711929, \\  0.0707106781186548, \\  0.0707106781186548, \\  0.424264068711929\\right]$"
      ],
      "text/plain": [
       "[0.424264068711929, 0.0707106781186548, 0.0707106781186548, 0.424264068711929]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_x.centerise.cov(data_y.centerise)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 0.989949493661167$"
      ],
      "text/plain": [
       "0.989949493661167"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAC0AAAAQCAYAAACC/vbpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAACPUlEQVR4nNXWMWhddRTH8U+CVkOQQig2g5qEUBBMEYVWDCSKWjqkS4tZpCAdBCcpilBQPD24ScAMDjo56CIRdNBYwRIahEAGoXZqKUm2klhMJC0VsU2Hd6/ePPL68t6b8lsO/3O+597fPfcP/3/X1taWvaaHdkpm5hjOYhR9+BNXMB0Rs53yDd65goEG5dWI6G9oOjM/xMe4iR9wAwfwHF7GbCd8E/2F6R3yt6qLbaYzc7Iw8AtORcRmXf3hTvhdaCMizjeDuso9nZnduI6DGIyIPx7U2CrfTMX2EBGDzdjqpEcxhG+xnpkTGMHfWIyIhbreVvnd6JHMPI2ncBu/Yz4i7jYyfaSIq/gNh6tgZs7j9cpEW+V3o358VZdbzswzEXGpTHRXio8X8W304DU8pja9nzGOmQ74ZvoSrxbGe9WG8AUG8VNmPluC1T39Cd7HPTwfEZdLKDN7cA1PYDQiFlrlWzC/TZk5hffwfUScZPuk14u4VDUAEXFHbXpwtE2+XX1exPEyUTV9tYgbDZpLkz1t8u1qrYi9ZaJqeh7/4lBm7tuheaSIK23y7erFIi6Vif9MR8RNfIP9+KjalZnHcFztxLrQDl+pDWfm09WDJzOfycy+ereZOYDPiuXXZb7+GH8XL+CDzBzHotp94CTu4q2I2OiAh4sFM+T/vzCJc5k5h2VsYhgTeFTtKjBVPqC6PUTEWmHiUzyJd/AKfsRYRMx0wj9Ac/iu+JA3imG8hF/xJk5ExD8l3LUXr6b3AfO4BEnBrvtdAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle 66.5$"
      ],
      "text/plain": [
       "66.5"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data_x*data_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAQCAYAAAAI0W+oAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAACRElEQVR4nL3VT4hXVRQH8M9oKioRmkowC7FsUYxBCoJKo4ISUhQzJIi4LYIWjn8QF+Lh6EIUFEdw76IWMkFSIU1UA1P+G1AIaSHBEGj0z7KYGMOEcfHuD5/XWXs35737vud8z/ecc+/rmpqa8iTWU/VGZr6BnXgZz+IXXMWJiLg0XZDMfA0DWIuF+AvXcTIizsOMyuEoPsdKfIFBXMPbuJCZO6YhOYBR9Baf4/gMC7DhMUWZ+Rz24je8EhG/t75txDc4hA9b+1txGF+hPyImqiRmdZ7bipaW9yttEoiIEUxgcSvIDBzFJLbXJMXv/8cU4Ufcw+rMXBQRt1tBe/E0zrXwa7EMH+NO6W0P/sNY3c+u9tRl5gBO4HYJ+idewFuaPuzoqM3MXQV7WtOfFZWgUbwTEX9QDUNEnER/Ufou9mMrbuJMVdIlxb6PudhUVPdguJAPdcD11O0rpThTlMzHKozjo8w81oLP7FSlZP51RPwbET+gD7ewPjPXPEKUmRs0zf00InZHxHhETEbEteL4M/Zk5vPF5U6x4xHxfVWZu0UVrK4VvVnsiGpFxCTGCv7Vsn2j2L9rfJXI3JpoTrGLTb86+/eKHcV9vJiZs6fB9xT7U030bbHvZWZ32yMzt2CdZnQvQhn/s3gGByv8ZryOfzS3xcPxLgdwWDM9E/gEv+IlTVm7MBARg62AS3ABy0uiY5qD34cpzUEeeoSoOM7CB9imuVTnaS7IMZyKiC/r+mTmQhwowbtLkt/hSERc7uC6ntRv4gEZrdW7kIBqYwAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle 86$"
      ],
      "text/plain": [
       "86"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data_x**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAC0AAAAQCAYAAACC/vbpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAABmUlEQVR4nNXWPWsUURSA4ScSUVjsUxk1hYJIYpnGFJY2EbQL2NqKFhbCySnsLCwstFKI/gWtdEH8BWLnVwRBFJGIayWyFjOGdbzCzGZXyIHhzr3cc9+XmTPDmRkOh3ZbzI5OMnMT8//Y+zEi5hr7z2EFS1jEATyIiLWuIl3Ys4UNX3GzsD4orF1TyQ7wHse6iI7LLklvRcR6S8gllewr1RPvt/crRit2Sbp1RMS2ZGbu5KhOUZLel5lrOIjveI6nEfHzP/i0Yu8pJM5hA9dV9fUELzNzZaq6HdhN6bs4XSf3cAJ3cAiPMnNxisKt2X+UR0Q0C/MFLmbmAJexjrPTMO7CLpVHKW7X46lJCHaMv9htpT/VY2+iOmOy20ov1+ObieqMyd6u6cw8jg8R8WU0IzPncaue3t+pQWYuYC9eR8SPcdijH+J5XM3MPt7iGxZwBvvxEDcah65itZ7+7g2WM/Neff85Iq40vB+reozD2ByHPSrdx1GcVL2SHrbwTPXv3IiIZku4hAuNtSP1Be/QlC5FJ/bMbmxNfwEaFJlDUuy6mgAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle 51.5$"
      ],
      "text/plain": [
       "51.5000000000000"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data_y**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGwAAAAUCAYAAABoF9hhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAEW0lEQVR4nO2ZXYhWRRjHf2tFhuUaSkpElkubtUk3UZqZpSBCdlFhF6GkF5kY9KVFHxd//4VQVBJqkZG4VFfdWPRhaOIHZV2ZSFgWmysVfqUlfhRZbhdzDh2P511n3n23ZWF/N8/7zpyZ53nmOTPnmZmmrq4uBug/DOprAwZI49z8h+3bgI2Ful2Sxv7fBg0AtkcAB4tlkpqgELACm4FNwK8VHV0GPAdMB4YDe4H3AUv6LcGgF4EbgFZgBPAHsCfra4WkQxVtOoHRNbrcL2lUrP5UeuK37TnA6rOoOCXpnML/E4Cz33Mo+F0VsE2SFlcobgG2ApcAHwDfATcCjwDTbU+sGugaPAZsA9YDB4AhwHhgMTDP9nhJP1W0OwK8WlF+LFJvMg3wezv/DX6ZScAUYG2xUNIJwljkK1+3AavF65nRD0tanhfaXkoIwBJgfmRfQyX9WS60vQR4BngaWFDR7veql6mX6ZHfkrYTgnYGtr/Mfr4Za0xU0mF7DDAN6AReK9sEHAdm2x4S019VsDLey+RVMf30No32u9T3dYRV5Rfg49h2sTNsSibXSTpVrJB01PYXBMfGAxtilVdwZyZ31Kg/3/Ys4HLCYO0Atkj6pwc6u6M3/X4wk6tS7I8N2NWZ/L5G/Q8Ew1tJMNz2IuBCoJmQhNxCCMILNZqMAt4ple22PVfS5li9CfSW3xcAs4BTwFspBsXuw5ozeaRGfV4+LEU5sIiwtDxKCNanwDRJByueXQ1MJQRtCDAOWAlcAay1fX2i7hh6y+97szZrayRXNUlJOrqjKZNJxyZ5Km57JHAzYWZ9bXuGpG2lZ8uZ1jfAfNvHgIWErOqudNN7RF1+A/MyuTJVYewMy9+k5hr1Q0vPJSFpv6Q1hOVlOPB2QvM3MnlrPbrPQsP9tn0t4eX8Gfgk1aDYgO3KZGuN+jyrq7XWRyFpD7ATaMt2+zEcyGRyphZBb/hdV7KRExuw/Mhqmu3T2ti+CJhIOK34KtWACi7NZKwzEzL5YwN0l2mo37YHA7MJycaqegyK+oZJ6rC9jrBkPQQsL1Sb8HavlHS8ZGALcB7QIelkVjaWsAHeV3p2EPA8YZO6tXjkY7sN2CvpcKnNaGBF9vfdst2224H7gbmS2mN8LVKP31U+F5gJXAx8lJps5KQkHQsIRzTLbE8FvgVuAm4nLAnPVrTZQDhWuZKw+YRwHveS7S1AB3AIGAlMBsYA+4AHSv3MBJ6yvRHYDRwFWoA7gMGEb8HLFfrzWfF3gp9lUv2u8jknTzaiTzbKRF+vSOog7JXaCQYvJAzaMmBCwjniZwSDhwN3A08A9wCHCW9tm6SdpTYbgTWEQbgPeJwQ4M8JM2iGpL8qdI0jBDf6JKFMo/y2fQ1h61JXspHTlF9gFq5X3AfndQ3H9jDC7H1F0pN9bE7d2N4ETO7uekW2Rf+/D5sEnASW9rUhqVTdh+UUA9bJ6dcAZ9yH9SckfUj4vvVHivdhp/Evw6KiDmdmHtcAAAAASUVORK5CYII=",
      "text/latex": [
       "$\\displaystyle \\left[ 0.35, \\  0.7\\right]$"
      ],
      "text/plain": [
       "[0.35, 0.7]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LinearRegression(data_x,data_y).coeffs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Bernoulli(\"X\",p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y=Bernoulli(\"Y\",2*p-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.stats import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAD8AAAAUCAYAAAA6NOUqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAACzElEQVR4nOXXT4hVZRzG8c8MIwaaSUkOQRpCEWU1WG0sMJBokZELl0FJUBD2RxgQJfj5WwRFEDS2SaJFYos2ZYuoFIL+0kZhAqGoGPsjRWqgRC3UcfGeW8fDvXfmjvfORH3h8vKe85xznuee9/297xmanp72f2Wk3snMF3AHbsAK/IljeAevRMTJ+TbYK5m5BRswhttwOfZHxENN7XCjvx1LcBAvYz/OYjcmM/PagbnuH89imxL+527CkUZ/WUT81RRl5nPYhZ14oj8eB8Z2/IRvlRHwUSfhReHbBa94Swl/ff1gZq7HZ9iDL5Q/5lYsxiR2RETHhw+C+vMys6u2Oew78UDVTjaOr6vae7EPp/AqPsGdeC8zV83yGfNOc9iDzBzHUlyhFMC7leDPN6St8Nfgnoj4tHaPCTyJpzDeX9v9oW14xezKWv99PBIRvzV0rfDb6sErXlPC33TJLgdE2/ARMQqZuRLrlTd+JDM3RcTh6txiJdiPyqrQpLUsLupmIDOnsLoHz22XrbnQ6c2DiPgVb2fmYXyDN7C2On2LEuyDiDjf5vLrqvaHGTx8h06Fth3He9B2pWv4FhFxLDOPYiwzV0TECf8M+akOl91ftR/OcO+Ns/EwCGZb7SlFDc5VbSv88qYwM6/EY8p6e2Cu5gbN3+Ez88bMHG0KMnO42uRcjc8j4vfq1O1VuyUzl9T0S/EmrsLTXfYOC85Q68MmM5/Bi/hYmYcnlYq/AWvwCzZGxNHMHMEZfK0sh+fxrrK5eVAZJTsjork0DpzM3IzNVXcU9+F7Ze8BJyJinIvn/CHsxV3KB8Fy/KEUun2YiIhTlfZmXKbs6l7CBB7FEL7E1ojoOtcHyBgebhxbU/0oH2rj1N58L2TmVryOxyNi75xtLjC9FLw6rWJ3pF9GFoJLCX8OX/XRy7zT87DPzGGcxlRErJ1J/29mTnP+v8IFlA/N0ZPo89QAAAAASUVORK5CYII=",
      "text/latex": [
       "$\\displaystyle 3 p - 1$"
      ],
      "text/plain": [
       "3⋅p - 1"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(X+Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFsAAAAUCAYAAADiOEEgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAE5klEQVR4nO3Za6xdVREH8N8tGIoE24SHJBC1LbQ8hJRKtAS9obYWUKI8QvQDEjRQGowgFkvBD5MhQYLVvgQFQpOmSRMklmJCGymPBqUglUejsYXWPoQoKAUDyCMIXD6sfcru5hzuuVdvvYT+v0wy66xZs2b918ysfXr6+vrswe7BiP+3Ax8m7N1OmZlLcSrGRMQru9elDzYy8zN4BBdExOL6WE8zjWTmCViHyyNi3m7zcgiQmYfhaoU4B+AZ3IGMiH8N0NZXcCmOrtl6FPMi4qHGb1dgMo6IiH+39O3SyI/wEn4xEGeGGzJznBKMbynkmY+tSsAeyswDBmDrOtyJSfgNFuIxfA1rM/PcxpRrcQguqSt3YXZmjscTuCUiZgxkc8MNmXkXpuOSiPhZTT8Pl+GmiJjZhZ1D8Dc8h+Mi4p+1sSm4D9siYmxj3kZ8FGMj4i3ey+xvowe/HPj2hg8yc6wS6O24oTEceAXfzMz9ujD3SSVOD9cDDRGxBi/joDbzbsUnMK2laBbIaXgLv+/CiUGhunLX4GAsx4yIeLViyVyMq9a/KCKeGuQyX6zk6oh4uz4QES9n5lrlMCbj3n5sbcYb+GxmHhgRO2p76cX+Sh1oYm0lv4S7qDG7OuWJ2DhUHUhmHosF+IGS707Eisw8BiuVKn4GNuH2zOwZ5FITKrmpw/jmSo7vz1BEvIAr8HFsyMybM/PazLwNq3E3Lmoz9Q+V7G0p6mnkUOylVNmhwmW4OiJui4jV+CpOVti1MiJmRsT9EXEp3sSUQa4zqpIvdhhv6Ud3YywiFuAsJRNciDk4B09jSTO9VHNexOtKKsGuaaRVndu2RJm5Xclf3WJZRDSr9KeVSt5y6M+ZuRgzMLvx2wdwjFKA/tdo3Ziuns+ZOVvp0hbhejyLI5WuY1lmToyIpv/wgnIjsGuwX6vkyA5rblFOqlv8vY2ux3s3uFW5UQdhW03f592gDBQt5o7qMP6xxu86IjNPxnVYERHfrw09lplnKqlqVmbeGBFbG9P39W5cdwl26yq07T8jYmp/jnWBDfg8/giZOQrfww78ODOnRETrMHpx1SDXebKSnXLyEZXslNPrOL2Sa5oDVWFfhzNxvEIckJkjlDS1k0D1YD+j9JITDB3m4+7M3KFcxWvwV8zEw1icmT9X8uNIg08hrcBMz8wR9Y4kM/fHSQrjuum69qlku/aurn+joZ+g3Mz1LcXOAlkx6rc4MDMP78KJASMi1itMnotVeB5nRcSfFAb1Kq+9afhGjeU7kZlLMrMvM89/n3W2KJ3Cp/Cdpgnsh6XNriszx2XmkZn5kZr6d5WckZmHNn5/mnJwr+PBxjqTK7nzRjT77OU4G6fgL502898gIpZhWRv9fTi8ycQ2aBHkzX6WulgJwKLMnIqN+JzS4WzCD9vMuVdpAsYoDyL4Fe5RCLCx+u7xLI5SCNKDORHxfMPWdOXN8uum4y0sxz9wXj8bGTL0E2g4Vnm1rezHzhacgCVKkGcpD6ZFOLFNcN7Pny8rbesGJT/PUpi7CqdExML6nKoWnYE7I+Lplr7dV78rlTZnUkQ83o1DuwuZOVpJPT/t0GoNC2Tmd5VD7Y2IVhpq+9VvPp5SPk0ON3wB/8Gw/fSbmfviSiyvB5o2zK4m9Cq57Sd7/jwYGDLzKHxdeVlur4+9AwmJt3AKbdPSAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, 0.8\\right)$"
      ],
      "text/plain": [
       "(-∞, 0.8)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_<1.4,p,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_x=Data(range(1,8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\left[ 1, \\  2, \\  3, \\  4, \\  5, \\  6, \\  7\\right]$"
      ],
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_y=Data([6,11,21,34,66,101,196])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7d00c396ea50>]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(data_x,data_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 62.1428571428571$"
      ],
      "text/plain": [
       "62.142857142857146"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_y.mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "v=Data([])\n",
    "for i in data_y:\n",
    "    v.append(log(i,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\left[ \\frac{\\log{\\left(6 \\right)}}{\\log{\\left(10 \\right)}}, \\  \\frac{\\log{\\left(11 \\right)}}{\\log{\\left(10 \\right)}}, \\  \\frac{\\log{\\left(21 \\right)}}{\\log{\\left(10 \\right)}}, \\  \\frac{\\log{\\left(34 \\right)}}{\\log{\\left(10 \\right)}}, \\  \\frac{\\log{\\left(66 \\right)}}{\\log{\\left(10 \\right)}}, \\  \\frac{\\log{\\left(101 \\right)}}{\\log{\\left(10 \\right)}}, \\  \\frac{\\log{\\left(196 \\right)}}{\\log{\\left(10 \\right)}}\\right]$"
      ],
      "text/plain": [
       "⎡ log(6)  log(11)  log(21)  log(34)  log(66)  log(101)  log(196)⎤\n",
       "⎢───────, ───────, ───────, ───────, ───────, ────────, ────────⎥\n",
       "⎣log(10)  log(10)  log(10)  log(10)  log(10)  log(10)   log(10) ⎦"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlMAAAAjCAYAAACw/I8AAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAONklEQVR4nO2de4wV1RnAfwuoVKCCIaZYo6SaGow0GMUoKj6iomLtamtRq1alRhFEYrCI0n79bDUgAREVjA9E7YvIH9aG8LC+wkNFyCIgtQlGsQaKEqItGxXR7R/nXHeYnbsz9945c2fuPb9kw+6535w598fZb889c2ZOS0dHB0lR1YXAQBG5OPFBFaCqA4B3gREi8l7CYxYDa0Rktos2uSKPLiuoO/fOXfu153Di2Pv99hxN6xd8jkibIvfZhOeuq/Nm99sry8Yk4C5gWViSqg4CpgMXAX2BrcAEEXkNuAd4VVWfFJHPsm5wjuniUlVHAncAJwKDgMtFZHHwoCQxeOcl9nOsqlOBy4BjgS+BN4CpIrK5dID3WxFRfXg8cBMw2Ba9A/xBRJaED1bVu4B7gUdEZELgJe/XUE2+TRrTrI7DOSHJ7zuqeouNG4Tp05NEZGXgdZ83DBX7VdV+wO+BS4HDgDbgNhF5KxRXU5/ukdpbrBFVPRi4EXgiVN4fWA20AKOB44BJwMcAIrIReB+4OrvW5ptyLoE+wNvAhC4HVRDjnZd1fBYwDxgBnAPsA/6hqocGYrzfBHTThz8C7sQkz5OAl4HnVfVHoeNPscdvDNft/Vafb5PGNKPjMk5jf99VdQzwIHAfcALG7VJVPbKSehrdebV+gceBUcAvgaHACkxe/n6g7v7U2KernplS1YOAGcCVwCHABmCyiKwKxPQB5mM+rbcDc4FTgV0icl2oytHAN8CqUPmvgR0icm2g7P1QzAvAVcAj1b6fehPnMw2XIrIUWGrri2xHkhhLoZxn0V9FZFTonNcAnwGnAX+3Md5vbX34b6G4u1V1nK1noz3PIcCfgLHAb8s0uVB+IZscQbJ8myQGcu44o5yQ5Pf9dmChiDxuf56oqhcC44CpFdQDOXKeB7+q2hv4GfBTEXnVFv9OVX+M8TvNltXcp2uZmbofGAPcgBlNbwKW2amyErOAMzHTa+dgRoUjy9R3OrBeRMKLuFqBN1T1z6r6sapuUNUJqtoSiHkTGK6q36nh/dSbOJ9puEyTojnPqr8G6Yf5HdtdRXu93xi/qtpTVa/ETMmvCbz0GLBYRF7upr1F8wvZ5IhW4vNtkhjIv+N65IT9UNUDMbOsK0IvrcDMcFdKnpzX3S9wINAT+CJU/rmtr0QrNfbpqmam7GhyHPCr0loFVb0ZI2M8ME1V+2IkXisiL9qYsZhp+igGA9sjyn9g63wAM1U3DHgI6KBzdLgdOAA4HMh0UVoaxPlU1emk4zJNCuM84/4aZA7m09gbVTTb+y3jV1WHAq8DvYH/Aa0issm+diNwDHBNTLML4xcyzRFJ8m2SGMix4zrmhDADMX/sd4bKdwLnVlgX5MR5XvyKyH9V9XV7vs3AfzAzZadi1kSVqLlPVzszdbStcHWg0V9jEtxxoZi1gZh2YDPR9Kbr6LHUxjYRmSoibSLyFOZNjg/EfG7/zcNovBrifKblMk2K5DzL/gqAqs7EfMK63J6rUrzf8n7/hUl2pwCPAs+o6vGqeixm3ckvRGRvTJuL5BeyyxFJ8m2SGMi348xzQgzh2ZaWiLIk5MV5nvxeg7k8+BHmxqCJwF+AYF6uuU9Xu2aqNPUV9Z/dkSAmil3AgIjyHZi7G4JswQgpUVrg+0nCc+WNOJ9puUyTIjnPsr+iqrMwixTPFpGtUTEJ8H7L+LUDpZLXdao6HLNYdBXmk/7mwPqJnsBI+6m4j4h8acuL5BeyyxFJ8m2SGMi340z7bMwxXwPfC5UfRtfZqiTkxXle/GLv/DvTzpZ9V0R2qOoi9l8TVXOfrnZmaiuwF7OwFgBV7YH5pLglEPMVcHIg5mDg+DJ1ttE5Yg2yGnOreZAfAtsCPw8FtotINZ0vD8T5TMtlmhTJeWb9VVXn0jmQ2tLlqOR4v8n7cA/Mp9bnMd6GBb7WAX+13wdnq4rkF7LLEUnybZIYyLfjevdZ4NsPBuuB80Ivncf+6wCTkhfnufAbRETa7UBqAOZSXvBmlpr7dFUzUyLSrqrzgemqugv4ALgNM7qeZ2P2qOoCYIaN2YFZOd+D6JHochs7UER2BcofANao6t3AIsxCtomY502UGAksq+a95IE4n2m5tNeojwnEDVbVYcBuEfkwaYylMM6z6q+qOg8zkGoFdqtq6dPmHhHZY2O839r68HRgCfBvzAL/qzCPpBgtIp8CnwYrUdV2jNvwpYPC+IXscgTJ8m2SGMix4wxzQpLf99nAs6q6FvNH/SbMmpxHSwcVLW/kya+qjrJ1vmtjZ2KWCjwVOK7mPl3L3XxTgOeAhZhFtsOAC0RkRyBmMrASczvhK5hroeuIuO5pF5C+CVwRKn8L88fp5/b4e4HfYP9D7Kr6VsyzJJyiqtepaoeqnuWg+jifNbvEPJenzX6B6VRtmIeRJY5x5bzOfqF2x+Mwf+BfwiSG0tfkQEzd/Nq6XTnOJB9gkvEfMcnwJWA4cKG9RToRBfULGeSIuHybNKYgOSKLPhv7+y4iizCXqafZdpwBXCQi2yqpJy3nKTrOhV/MYxkexgymnsEsBzhfRL4K1F1zn26pZDuZWlHz3IltwEwRmRXx+ijMoq8hSRftquoE4BIROT/Vxkaf6zrMaPZs6XxmRV1w4bKCcztxnie/UD/HLvt0nhx7v27xOSJ96uk0QdtScV5Px0X263Q7GVU9ARiCWa3fDzNS7YeZRuuCiCxX1YeBI+h6rbIce4Fba29tvsnIZVIa0nmOHHu/eL+VkiO/0CCOc+Y0jsI5byS/WezNdztmYdc+zFTfSBEp9xwJRGRuJZWLyGM1ta5YOHWZlAZ3XnfH3m8n3m/F1N2vrbeRHOfCaRwFdt4Qfp0OpkSkDXNN01Mj3qV7vGO3eL9u8X7Txzt1SyP5zXTNVJFQ1Q+Aoyo45GnpupeQpwzer3u8Y7d4v27xft3jHadHFpf5isocoH+obBjwE+BpzK2eQTY4bk+jMQfv1zVz8I5dMgfv1yVz8H5dMwfvOBVaOjo6UNWmnZ4SkfBGhmWp9i4H7zcZ3m/lVOIXqnPczH7B92HXeL9u8TnCPSLS0qv0Tb0b08h4v27xft3i/brHO3aL9+sW77eCy3yquhAYKCIXu2qMmse8vwuMELOfTlr1LgbWiMjstOp0gWvHrvzaunPv2Pdht3i/7vE5wi2+D7ulkf32CgR+QPRCtHkiEt452RV3ActKAlR1JHAHcCIwCLhcRBaHD1LVW2zcIMxmhZNEZGUg5B7gVVV9UkQ+c/weIsmjX9uuhnCcE7/QoH3Y+3VPThz7HOGehuzDze43uJ3McFtJ6au08eJzNb6xRKjZ4PBG4IlAcR/gbWBCN8eNAR4E7sPsp7MaWKqqR5ZiRGQjZofoq9NveWLy6Bcax3Fd/ULD92Hv1z0+R7jF92G3NLXfXoHAT0KV3wm8B7xW5uQHATOAKzF732wAJovIqkBMH2A+cBnQDswFTgV2RdxeORr4BrNvTqlNS4Gltq6oZoB54NdCESntlzNRVS/E7JM2NRD3AmZT1EfKVRSHiCzE7DNUzbEV+bUx3Tqu1a9tV24cF9wvNHAfduHXxvgc0XlsvfuwzxEhfI6o6LimzhGRGx2r6oGY0dcCESm3Sv9+YAxwA2YktwlYpqqDAjGzgDOBS4FzgKGYXZejOB1Y3835yrXzRGBF6KUVwIhQ2ZvAcDWbFdaVhH4h3rFTv4G2FspxnfxCk/ThFP2CzxGR+BzhFp8j3NKMOSJyMIXZGbk/ZUandqQ4DpgiIktE5J/AzcBOYLyN6YsRNEVEXhSRd4CxQLnNCQcD28u8Vo6BQE973iA7MbvLB9kOHAAcXuE5XNBKN34h3nFGfqGYjlvJ3i80Tx9upUa/NsbniPK04nOES1rxOcIlrTRZjig3mBoLLBWRco062la4ulQgZgfn14HjQjFrAzHtwOYydfYGvijzWhzhUWhLRNnn9t+6f+ok3i/EO87SLxTLcT38QvP04TT8BmN8juiKzxFu8TnCLU2XI7o8GkFVjwLOxVyfLEfpmRJRU2kdCWKi2AUMSBgbPOZruo4eD6PrKPNQ++8n1JGEfiHecRZ+S8cVxnEd/UIT9OEU/cbFRNHwfsHnCNf4HOGWZs0RUTNT1wMfA0u6OflWYC9wWqlAVXsApwBbAjFfAScHYg4Gji9TZxudo9FEiMheYD2ddw2UOA9YEyobCmwXkbCcrEniF+IdO/cLhXRcL7/QHH04Lb+lGJ8juuJzhFt8jnBLU+aI/Wam7Bu5HrOZ4b5uTt6uqvOB6aq6C7N/z22Ykd08G7NHVRcAM2zMDmAaZgAXNcpcbmMHisgu256+wDGBmMGqOgzYLSIf2rLZwLOquhYzXXgT5nrmo6H6RwLLyr2nLEjqF+Idp+HXtqlhHNfZLzR4H07Tr43xOSKEzxFu8TnCLc2cI8IzU+cCRwILupNgmYJ5fsRCzO2Mw4ALRGRHIGYysBJzO+ErmOuc64i4pikimzAr5a8IFJ+EGWm22Z9n2u/vCRy3CJiEEbwBOAO4SES2lWLsyvtWoHTbY72oxC/EO67VLzSW47r5habow2n7BZ8jwvgc4RafI9zStDmipaOjortga0LNMyW2ATNFZFbE66OAh4AhdiFaWuedAFwiIuenVWceqZdfW3fDO47za2N8H64BnyPc4nOEW3yOcE9ec0TivfmqPPkJwBDMSvx+mFFoP2BRVLyILFfVh4EjMLLSYi9wa4r15YIc+YUGdFypX/B9uFJy1Ie9X3yOqBSfI9yToz7crV+nM1NWwuPAscA+Op9uut7ZSZsI79ct3q97vGO3eL9u8X7dUxTHmV7m83g8Ho/H42k0yj200+PxeDwej8eTgP8DDjPN6qxmuQMAAAAASUVORK5CYII=",
      "text/latex": [
       "$\\displaystyle \\frac{\\log{\\left(6 \\right)}}{7 \\log{\\left(10 \\right)}} + \\frac{\\log{\\left(11 \\right)}}{7 \\log{\\left(10 \\right)}} + \\frac{\\log{\\left(21 \\right)}}{7 \\log{\\left(10 \\right)}} + \\frac{\\log{\\left(34 \\right)}}{7 \\log{\\left(10 \\right)}} + \\frac{\\log{\\left(66 \\right)}}{7 \\log{\\left(10 \\right)}} + \\frac{\\log{\\left(101 \\right)}}{7 \\log{\\left(10 \\right)}} + \\frac{\\log{\\left(196 \\right)}}{7 \\log{\\left(10 \\right)}}$"
      ],
      "text/plain": [
       "  log(6)     log(11)     log(21)     log(34)     log(66)     log(101)    log(1\n",
       "───────── + ───────── + ───────── + ───────── + ───────── + ───────── + ──────\n",
       "7⋅log(10)   7⋅log(10)   7⋅log(10)   7⋅log(10)   7⋅log(10)   7⋅log(10)   7⋅log(\n",
       "\n",
       "96)\n",
       "───\n",
       "10)"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 1.541337646857$"
      ],
      "text/plain": [
       "1.54133764685700"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADMAAAAQCAYAAAC7mUeyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAACwElEQVR4nN3WW6hWVRAH8J96oOB0AyWlILvQBSwk6MEyuhBI0QUszlsUPdSDgRgKlRDjKIKS0AUhi+BE9hREvmRG0UGLHoIkLCIEU+vBo2IZFUllx4e1lM/t/i7ne6t5mb1nzcx//fesPbNmTE1N+b/IyOmHzJyNpbgfN+Fy/IVvMI7xiPi3MzgzD2B+l9yHI2Je05iZG3ELrsMc/ImD2IbNEXGsJWYgnJEO4xhewyFM4EfMxcN4E/dl5lhENEv5K15uAfm9C/gz2I2PcQSjWIQ1eCozF0XETy1xfXE6yezFQ/igswKZuRpf4pFK7L1GsuMRsabLxtvkoog40TRm5nqsxvNY1hLXF+cMmYj4tM0hIiYzcwvW4y7nkpmWtBGp8q5C5tphc4/0dwF/V/1Py9p5mfkorsAf2INdEXFymnt5sOo9Xdb74vQlk5kjeKy+7mhxmYetDdv+zHwiInb2yLsKF+BipSHcXje4oUtIX5yZvYhU2YAbsT0iPmqsjeOeCjSqdMHXcSU+zMyFPfKuQmBFJbIDSyLiaIvvQDgzes2ZzFyOV/A9FkfEzz021xm3CSuxLSKW9vGdi9uUj3YhHoiI3cPgdK1MZj5diXyHuwclUmVL1Xf0c4yIwxHxPpZgNt4eFqeVTGauwGZ8qxCZnAYAZX5QjsRAEhEHlQ+3IDPnDINzDpnMfBYv4WuFyJGmzwBya9U/TDPusqoH7YRn4ZzVzTLzBazFV8rP2PVoZeYCHGr6ZOZ8parwTmPtBmX4TTbsM7EOl+KLiPhlGJzOu9njlchJfIblmdnkcCAi3qrPY3guMyewH7/hGuVudz62Y1Mj/l68mJm7sA/HlCvTnbgak3iyETMwTmdlrqp6ltIu22QnTpOZwPW4WSn3KI7jc2UebG25x32CN7AYC3GJMgD31phXW07DwDg9W/N/TU4BlV0aBIVuJYsAAAAASUVORK5CYII=",
      "text/latex": [
       "$\\displaystyle 2535$"
      ],
      "text/plain": [
       "2535"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data_x*data_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\frac{\\log{\\left(6 \\right)}}{\\log{\\left(10 \\right)}} + \\frac{2 \\log{\\left(11 \\right)}}{\\log{\\left(10 \\right)}} + \\frac{3 \\log{\\left(21 \\right)}}{\\log{\\left(10 \\right)}} + \\frac{4 \\log{\\left(34 \\right)}}{\\log{\\left(10 \\right)}} + \\frac{5 \\log{\\left(66 \\right)}}{\\log{\\left(10 \\right)}} + \\frac{6 \\log{\\left(101 \\right)}}{\\log{\\left(10 \\right)}} + \\frac{7 \\log{\\left(196 \\right)}}{\\log{\\left(10 \\right)}}$"
      ],
      "text/plain": [
       " log(6)   2⋅log(11)   3⋅log(21)   4⋅log(34)   5⋅log(66)   6⋅log(101)   7⋅log(1\n",
       "─────── + ───────── + ───────── + ───────── + ───────── + ────────── + ───────\n",
       "log(10)    log(10)     log(10)     log(10)     log(10)     log(10)      log(10\n",
       "\n",
       "96)\n",
       "───\n",
       ")  "
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data_x*v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 50.1229505929714$"
      ],
      "text/plain": [
       "50.1229505929714"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 3.46736850452532$"
      ],
      "text/plain": [
       "3.4673685045253166"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10**0.54"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\left[ - \\frac{2 \\log{\\left(196 \\right)}}{7 \\log{\\left(10 \\right)}} - \\frac{\\log{\\left(101 \\right)}}{7 \\log{\\left(10 \\right)}} + \\frac{\\log{\\left(34 \\right)}}{7 \\log{\\left(10 \\right)}} + \\frac{2 \\log{\\left(21 \\right)}}{7 \\log{\\left(10 \\right)}} + \\frac{4 \\log{\\left(6 \\right)}}{7 \\log{\\left(10 \\right)}} + \\frac{3 \\log{\\left(11 \\right)}}{7 \\log{\\left(10 \\right)}}, \\  - \\frac{3 \\log{\\left(6 \\right)}}{28 \\log{\\left(10 \\right)}} - \\frac{\\log{\\left(11 \\right)}}{14 \\log{\\left(10 \\right)}} - \\frac{\\log{\\left(21 \\right)}}{28 \\log{\\left(10 \\right)}} + \\frac{\\log{\\left(66 \\right)}}{28 \\log{\\left(10 \\right)}} + \\frac{\\log{\\left(101 \\right)}}{14 \\log{\\left(10 \\right)}} + \\frac{3 \\log{\\left(196 \\right)}}{28 \\log{\\left(10 \\right)}}\\right]$"
      ],
      "text/plain": [
       "⎡  2⋅log(196)    log(101)    log(34)    2⋅log(21)    4⋅log(6)   3⋅log(11)     \n",
       "⎢- ────────── - ───────── + ───────── + ───────── + ───────── + ─────────, - ─\n",
       "⎣  7⋅log(10)    7⋅log(10)   7⋅log(10)   7⋅log(10)   7⋅log(10)   7⋅log(10)    2\n",
       "\n",
       "3⋅log(6)     log(11)      log(21)      log(66)      log(101)    3⋅log(196)⎤\n",
       "───────── - ────────── - ────────── + ────────── + ────────── + ──────────⎥\n",
       "8⋅log(10)   14⋅log(10)   28⋅log(10)   28⋅log(10)   14⋅log(10)   28⋅log(10)⎦"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LinearRegression(data_x,v).coeffs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 0.546266721003393$"
      ],
      "text/plain": [
       "0.546266721003393"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(answer[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 0.248767731463403$"
      ],
      "text/plain": [
       "0.248767731463403"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(answer[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_x=Data([20+2*i+1 for i in range(7)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[21, 23, 25, 27, 29, 31, 33]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_y=Data([7,11,21,24,66,115,325])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 11, 21, 24, 66, 115, 325]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 5215$"
      ],
      "text/plain": [
       "5215"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data_x**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17777"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data_x*data_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1.0$"
      ],
      "text/plain": [
       "1.00000000000000"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.94591014905531,\n",
       " 2.39789527279837,\n",
       " 3.04452243772342,\n",
       " 3.17805383034795,\n",
       " 4.18965474202643,\n",
       " 4.74493212836325,\n",
       " 5.78382518232974]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Data(map(N,map(ln,data_y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 21 \\log{\\left(7 \\right)} + 23 \\log{\\left(11 \\right)} + 25 \\log{\\left(21 \\right)} + 27 \\log{\\left(24 \\right)} + 29 \\log{\\left(66 \\right)} + 31 \\log{\\left(115 \\right)} + 33 \\log{\\left(325 \\right)}$"
      ],
      "text/plain": [
       "21*log(7) + 23*log(11) + 25*log(21) + 27*log(24) + 29*log(66) + 31*log(115) + 33*log(325)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data_x*Data(map(ln,data_y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 717.395333281913$"
      ],
      "text/plain": [
       "717.395333281913"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81.28571428571429"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_y.mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "z=Data(map(ln,data_y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\log{\\left(7 \\right)}}{7} + \\frac{\\log{\\left(11 \\right)}}{7} + \\frac{\\log{\\left(21 \\right)}}{7} + \\frac{\\log{\\left(24 \\right)}}{7} + \\frac{\\log{\\left(66 \\right)}}{7} + \\frac{\\log{\\left(115 \\right)}}{7} + \\frac{\\log{\\left(325 \\right)}}{7}$"
      ],
      "text/plain": [
       "log(7)/7 + log(11)/7 + log(21)/7 + log(24)/7 + log(66)/7 + log(115)/7 + log(325)/7"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3.61211339180635$"
      ],
      "text/plain": [
       "3.61211339180635"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "27.0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_x.mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=data_x.centerise*z.centerise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 34.7059022305121$"
      ],
      "text/plain": [
       "34.7059022305121"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "N(sum(_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxkAAAAVCAYAAAAqySMZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAN7UlEQVR4nO2de7QVVR3HP4CZiIaJCfkI0MRMW6KRiimKCNpSyxeupUsEXb4tvCZlPPTnz9QwU/FVPgMtTSxSKwEf+cBnlormk1IwTcX3M/AF/fHbcxnmzpwzM2fmzpxz57vWWfvesx+zz/w+s397z569p9vy5cupVKlSpUqVKlWqVKlSpazUvegKVKpUqVKlSpUqVapUqbW0StEVyEqqOgBYCFwlIuOKrY1JVa8GdgcGisiHKcv4JvAP4HARuTLL+jWDWtWuKY/bpVmA8vFQFAvu2F2ah7KxAFXbUJQqFhpTxU/FTyOqxU8ugwxV3RFoA7YH1gbeAv4JTBOR2QnK2QA4DTvRfYBXgBsBFZG3s611tlLVIcDBwAQ/IKo6DpheJ/syEekBICIPq+qNwOmqOlNEPsipyomkqmOAq92/R4jIFQnzN6Vto+zq4vYHdgIGA1sCawLXiMjBNcqLnacMLKhqH2AfYA/gG8D6wMfY9T0dmC4iyxKW2VIspD1HSfkpmoeKhZVVq21w8Yn9Ytw8RbMQpq7qI6Bm25Crj/DlWQT0j4heLCL9/F+UiZ+q/1iTn7OAIcAgYB1gCfAC9rsuEpE3A+Wk9UWLyIifzB+XUtUpwDxgGDAXOAf4M/BFYOcE5WwMPAwcCjwEnAc8DxwPPOBOXpl1JvAe8KvA9/MBjfjc4dLMCeT5GdAPGJ9TXRNJVTcELgRSNURNbtsouwJMAb6POYP/xiwvaZ6iWRgNXA5sC/wNmAbMArYArgCuV9VucQtrURbSnqM0/BTJQ8XCyopsG9L4xRR5im4b2tXFfQREs9AZPsLTu4T3M34Rkb5wfqr+Y7ui+DkB6AXcBpwPXAN8CpwKPO6uO78aaaMz4SfTmQxVHQ38FLgd2FdE3g/Efy5Bcb8E1gXGi8iFvjLOxU70GcDRDVc6B6nqIGBX4AoRWeKPE5H52EAjLN8D7s/LAnkeUtVngKNU9SwR+SzzSseUA3I68CbwR2BCimKa0ra17Op0AvAS8G/sztOdMYpNlKcELCwAvgvc7L8DoqqTsMZ8P2BfrCGLo1ZkIe05SsxPozz4ZlaHi8hdSfJSsdCuWjyk8Ytp8hTMgr+cLusjoG7bkLuP8OkdETk1ZtrC+an6j6Y6/HxBRJaG5DkDmARMBI71RTXSRmfCT2aDDFXtDpwF/A84KAiIq8QnMcvaCBgFLAIuDhYDHAmMUdUT4z6rpqoHYHcDtgRWxS7Ya4FzReSjQNpu2GjsKGAjrLG8AZgMPOZ+y4AahzsM6AbMjFM3d8wtgO2wOxU3hyS5Dhut7grcErfcHDQe2AW7q7BL0sxZ27ZMdhWR9sZfVetVPXUeCmRBRO6I+P5VVb0Ea7x3JkbHslVZSHuOUrIABfHQKiy49LnwkMYvNuhLy+AnmtZHuPR5tg2d5SPSqhB+ytx/LBk/HQYYTtdjg4xNAukza6NjqgM/WT4utT0wEJgNvK2qe6jqSap6vKoOTViW1zDdGnxezMF3H7A61imvK1U9EzPYZhgcF2FGPBO4JWSEfDE2rdQbm1X4HQbtbUCc0fSuwGfAg3Hq53SUC6+MuINwnwtHJigzU6nqZsBU4HwRmZeymMxs2yR2zUOFsxAhzwl8GjN9V2Qh6TmKozLy0EwsQH48pPGLjfjSQlloAR8BreMnPq+qB6vqJMfOcFXtUSdPUfyUsv/YRPzs5cLHE+Sp10Znwk+Wj0t9y4WLgUewRSbtUtV5wP4i8nqMsjZ14YKI+H9hRhsE/LVWQQ7QicCLwDYi8qr7fiI2utwT+BEGjbfo6Bh37G1F5B33/SRsGm89bKFN1PF6Yc9OPp1glqUntshnGfacXJj+7sJhccrMWqq6CvAb4D/YiDmtMrFtM9g1RxXKQpgcH4e4f+fGzNalWEh5juKoVDw0EwsuLk8e0vjFRnxpYSw0u49wca3kJ/ph9vBroaoeKiJ3R+Qpip/S9R/LzI+qTgDWwAYyQ4AdsAHG1Kg8gfxx2uhM+MlyJmNdFx4N9MRGY2tiC0xucQf9fcyyervw3Yh47/u1YpR1mAtP9yABEJFPgROxjv3hvvRjXXiGB4hL/zEGXD2tD/TAdjKIqwOw3zJHRF4MSyAi7wJLga8kKDdLnQJsBYyLWI8QV1nZthnsmotKwEKYpmLX+mwRiTvN3tVYSHOO6qqEPDQTC5AvD2n8YmpfWjALze4joHX8xHRgBNZR7IV12i8FBgBzVHXLsEwF8lPG/mOZ+ZmAPfrVhg0w5gKjYg7CoH4bnRk/K81kaO1tq8Lk30bNm0bpho04H3P/P6mq+2Aju51UdaiIPBAsKKG81fBxXle+tQs7PJsmIgtU9SVgoKqu5aDYykXfG1LWg9Sf/vd2LUiyRdqRLry0Trq3gL71CmvQjmHlbYPdmTonA9vVU1zbNoNd81QhLEQcYzzW6D4DjEmSt45ahoUcz5GnujzUYeHOkOe9E+8Z34QsQL48pPGLjfrSTmehRXwEtIifEJGgAZ8AjlbVD7Dr81Rsa9MwFdGWlLH/WFp+xG0hq6p9sUfNpgKPquqeIvJIrbxx2ugs+QnOZDwHPJvg87Ivr3dSnvcB4lV4CSsWEW0TUTG/vJFm74j4LwTS1ZJXRtTI8JVAOi9cHEzo1kq8Gfw+IO8Ozmox6oaqfh2D5CXsecRa6ukrv5YasWOwft4U+ALg5BjHrqesbFtqu3aCOp2FMKnqcdhWek9hu4q8lSB7l2ChwXMUV3F4mAYdtiO8ycVdFRJ3Y5IKNCkL/r/z4CGNX2zUl3YqCy3kI/x/t4qfCOoSF9Z6HKqItqSM/cfS8yMii0XkBuzxrz6seC9NqDLwRYn5WWkmQ0RGJDygX8+68J2IeA+ingnKGhQR762gj3rmzi8PpH5YhyuoLwfSvefCvti+yu1yi176UHuv6tdcGHcf5noLvr1jd8em9xbWK7BBOwa1BivssDTkDgXA5ap6ObbYr61OeVnZtux2zU0FshCsRxu2//gTwAgRea12jg5qeRYyOEd1FZcHEZkWkncc8D1ghjS2bWkbzckC5MtDGr+Y2pcWxEKr+AhoIT8RIa9+vcIiC2xLyth/bBp+ROQFVX0KGKyq64jIG8E0GfmixPxkuSZjHjYVtImqrhoSv4ULF8Uoy9uybZSrdLtUdU3g29hIKc7q+0dduHMwQlW/CmwALPRNd3npdwgpazvqL5Z/BXidFYuPIqWqq2HTVcuAK+sk3xSb5ptfr9yM9RFWt7CPd67udf/HmcbMyraltWsnqCgW2qWqJ2EN1nzsjkiaBqulWcjoHMVRoTw0OQv+PHnwkMYvNuJLi2ChVXyEP08r+IkweTs1PR8RX1RbUsb+Y7Pxs54LO9ysztAXJeYns0GGGznNxKaLTvHHqepIYDdsxDc3ELexqn5NfVuBichzwK3YIpPjAodSbBR1da3V9z792oVTVPVLvuP2wN5c2J2VO/jedNNkVe3tS78qvl0EoiQiy7ELZh0HYi2Nxt5kOTtqwbdP3nZrd9ZMlbFEZImIHB72Af7kkl3lvpvp5QuzqysvK9uW2a55qxAWPKnqydgzoA9jd0Q63DUJyZPndV46FtKcowZUGA8twALkyEMav5jWlzp1OgtpfQR0LRY6S6q6uaquHfJ9f2wLVoDfRmQvqp9Rxv5jqfhxv7NfMI+qdld7Gd+6wP0i8nYgPlEbnTU/mb7xG/gh9vryyao6DHujYH9sgchnwBGBUR/YFmL9sT2SF/m+Pxa4H7hAVUcAT7uyh2PTXJPjVEhE7lfVnwM/Bp5Q1T8AHwLfwUbH9wJn+9LfraqXYYuxn1TVWdh+wnthkL+MzTzU0izsTYq7YS9uiZK34PuyGmk8jcLO4U31EpZEUXaFDGxbRruq6t7A3u5frzEYqqoz3N9viMiERvNQIAuqOhY4zR3/HmB8yOMRi0RkRuC73K7zsrGQ9hylZAEK4qEVWHB58m4b0vjFNHmgdfxES7LQST5iNPATVb0Te2zlfWBjYA/sWf/ZWCc5TEXyU6r+Ywn52R04W2073+ew9R19sbfAbwS8ChzhLyhlG50pP1k+LoWbgtkWm5bZkBVv/rwZ2FFE4m5B5o1GhwAzXJknYj/0AmCoiNRbQOMv6yTgQGx/5ENcvboDU4CRYtuL+XUMBvwH2JZqB2F7HI/EFg29R23Nwhb+HBKVQO2lRTsQY8G3GxHvDfwlxoxH6ZWVbUto18HYFnZjsQYC7OL3vtu/0TwlYGGgC3tg2+dJyGdc3MJalIW052gwCfkpmIdWYQFy5CGNX0yTpwRtQ2ZqVRboBB+B3UW+Abs+D3K/ZSesUzwW2DPsdxfNTxn7jyXj53bshnQfYF/sHR37Ybs5KbC5iDwVyJOmjc6Un27Lly+v83sreVLVTbBR8HUicmCdtBOx6bGtReTRWmljHPcH2MUxTETuaaSsSh1VlF3TqGIhXzUTC64OFQ85qpl4qFjIV83EQhpV/OSrrspPpjMZrSJV7acdFwytjm3bBjbKq6fzsDefntZgXXpiL3GZVV34jalMdk2jioXs1OwsQMVDlmp2HioWslOzs5BGFT/ZqeJnZX6yXpPRKmoDDlTVu7DV/v2wtx9uAMwhxpsnRWSpqo4BhqtqrxiLjKI0AJsim5Eyf6UVaqM8dk2jAVQsZKU2mpsFqHjIUm00Nw8DqFjISm00NwtpNICKn6zURsVPu6rHpULkFgpNwJ6FXBvbWm0BcC0wTUQ+Ka52ldKqsmslTxULlfyqeKjkqWKhUiOq+FlZ/wd9U6kp20+uDQAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle - 6.0 \\log{\\left(7 \\right)} - 4.0 \\log{\\left(11 \\right)} - 2.0 \\log{\\left(21 \\right)} + 2.0 \\log{\\left(66 \\right)} + 4.0 \\log{\\left(115 \\right)} + 6.0 \\log{\\left(325 \\right)}$"
      ],
      "text/plain": [
       "-6.0⋅log(7) - 4.0⋅log(11) - 2.0⋅log(21) + 2.0⋅log(66) + 4.0⋅log(115) + 6.0⋅log\n",
       "(325)"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data_x*z)-7*data_x.mean*z.mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 34.7059022305121$"
      ],
      "text/plain": [
       "34.7059022305121"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\left[ 36.0, \\  16.0, \\  4.0, \\  0, \\  4.0, \\  16.0, \\  36.0\\right]$"
      ],
      "text/plain": [
       "[36.0, 16.0, 4.0, 0, 4.0, 16.0, 36.0]"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_x.centerise**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADoAAAAQCAYAAABHjGx4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAACcklEQVR4nOXXW4iVVRQH8N94eTG8gCCCQTmS+lDog1DUQ02CRkGo5ZsmvUhg2IiCEMViCYJP3hUhYSTwRRDswSgfkghvgSAUalPGBIlDWBEhQVbTw7ePnr7xMOeMwRFc8LHYa//X2vu/L2uvr2dkZMTDIJOaG5n5Op7HYizCVByNiDX3ch4HfiZW4hU8hTn4E19hAAMR8U8nBDLzUWzDS5iJGziBjIhfG7gJNb/38HaZ+PU2xukUvxof4GlcwG4cx5M4jGOZ2dNGHJCZ83ARb+JL7ML3eAfnysKitqPYhB/xnWqnTo8xVqf4QbyKk807l5nvlom+hlUq8u3IQczCxojY1xRvZ5nbdrxFjWhEnG4CjznKOPCftbAPZ+ahMrEXtEE0M3uxDEM4UA+J9VibmZsj4lb96HZTbhf9V5v4F4s+Vb/XEfE7zmAKnmH0He2KZOYkvFGan7TptqDowRb93xY9nweEKHaoEtLHEfFpmz7Ti/6tRX/DPoMHgGhmbsRmXMXa/zF0I3uP0GWimbkBe3AZfRHxSwfujR2b3qJ/WjOua0Qzsx/78bWK5HCHIb4pen6L/ieKHqRLRDNzq+pxv6Qi+dM4wjSetmWZ+R8emTkVz+EPnKcLRDPzfVXyuYilEXGzDZ95mbkwMyc3bBFxDafwODbUXfAIPoyIW9DTXNRn5gqsKM3ZWK4qqb4otpsRseU+8OtwBH9jn3tnzKGIOFIjOoTHMDcihpoXAGdV1dFHuKIqL/tUR/bZiPiZ0SXgYqyr2XrLBz9gy33g5xY9Ef2jKFbyuWoxxpSIuJaZS9wt6l9WFfV7VUX9neTW87D8pv0L2LHa6FHEDIkAAAAASUVORK5CYII=",
      "text/latex": [
       "$\\displaystyle 112.0$"
      ],
      "text/plain": [
       "112.000000000000"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\left[ - \\frac{73 \\log{\\left(325 \\right)}}{56} - \\frac{23 \\log{\\left(115 \\right)}}{28} - \\frac{19 \\log{\\left(66 \\right)}}{56} + \\frac{\\log{\\left(24 \\right)}}{7} + \\frac{5 \\log{\\left(21 \\right)}}{8} + \\frac{31 \\log{\\left(11 \\right)}}{28} + \\frac{89 \\log{\\left(7 \\right)}}{56}, \\  - \\frac{3 \\log{\\left(7 \\right)}}{56} - \\frac{\\log{\\left(11 \\right)}}{28} - \\frac{\\log{\\left(21 \\right)}}{56} + \\frac{\\log{\\left(66 \\right)}}{56} + \\frac{\\log{\\left(115 \\right)}}{28} + \\frac{3 \\log{\\left(325 \\right)}}{56}\\right]$"
      ],
      "text/plain": [
       "⎡  73⋅log(325)   23⋅log(115)   19⋅log(66)   log(24)   5⋅log(21)   31⋅log(11)  \n",
       "⎢- ─────────── - ─────────── - ────────── + ─────── + ───────── + ────────── +\n",
       "⎣       56            28           56          7          8           28      \n",
       "\n",
       " 89⋅log(7)    3⋅log(7)   log(11)   log(21)   log(66)   log(115)   3⋅log(325)⎤\n",
       " ─────────, - ──────── - ─────── - ─────── + ─────── + ──────── + ──────────⎥\n",
       "     56          56         28        56        56        28          56    ⎦"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LinearRegression(data_x,z).coeffs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 0.309874127058143$"
      ],
      "text/plain": [
       "0.309874127058143"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(answer[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANAAAAAQCAYAAABnTPHAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAH2klEQVR4nO2baYxW1RnHfyzWBQUUWom2oWCKa+tILBUlVsQSBWsRxfgBqjQFjVbEJYqoffhr1DEtqKM2pWiAUpJK3KIICCrR1jVxiQtWKAguFVqlKgioOPjhOZc5c+fel/ved5jMh/knk8N77rnnWe5zznmWQ6cdO3bQgQ50oBy6pjskfR+4ATgV6AV8BDwMyMz+X3RiSbcCxwIDgN7AVmBdmOsuM/ukVtqSOgHjgYnAkUAX4B1gNnC3mX2Tw9tI4FLgiIjOy8AMM3s+GtcLOBMYCfwYOBj4Cngj0JhtZo0Z858N/ByoA44G9gPmm9nYbG1l8jgO+Gv4OcHM7kk9L8tbIdmj8WuBvjlsbjCzPmHc+YFuJTSaWZfU/O1SV0Vtq3PqpUNwZY4HXgJuA9bgCn8+MFIUlwHdgGXAHcB8YDswDXhd0g9agfZc4F6gH3AfMAv4TqB3X1BCM4SFvRAYCCwJY18BfgU8Kyn+cGPCnD8DXgRuBx4AjgLuARZk0QCuA36HG8WHmdqpgKCbO4HNFYZVzVuVssf4DFDG3x+jMa/ljBHwVBizOGPudqkrCtpW+gT6E/A9YJKZ3RkxOQNfEDcBFxaUrbuZbUt3SroJmApcA1xUlrakUcA44F1gkJl9HPr3ABYAZwHnAXOid/oAVwIbgJ+Y2X+jZ0PxD30D8LfQvRI4A3gs3qEkTcUX+VnAaPxjxLgM+AD4N767Ls9TUhrhw8wGPgEeDPxmoSreSsge41Mzm1aJbzN7DV9EWTIlJ9tfMh63R12NoqBtdY4m6w8MB9YCd6cYMOALYJykbkWEy1o8AQtC+6MaaY8O7fREwED3a+D68POS1Fx98VP3xdiAwnvLgU3Ad6O+p8zs0fTxbmbrgT+HnyelBTSz5Wa2yszKBJiTgJPxk/iLvEEleKtK9taCpKOA4/DT5bH083aqq8K2FbtwJ4d2aQahTcCzwD64MmrBL0P7eo20+4R2TQaNpG+gpJ5R/yrc9x0kqXf8gqQTcf/7iWJi8HVotxccv0tIOhyoB+4ws2dqmCqLt1pk31PSWElTJV0qaaikLjlj07ggtPfmxaRlsJt1Vdi2Yhfu0NCuzCG0Cj8lBgBPFuVO0pXAvkAPPKkwBF889TXSTnaGfhnj+0f/Pgx4AcDMNkq6GpgBrJD0MH78H4If8cto+uCVZOoK/Dr8XLKr8UUQ5pwHvIe7uLXM04K3GmXvE3iL8a6k8Wb2dAVe9gbGAo14rNEq2N26ogrbik+gHqH9LIde0t+zCh7B/VIDJuOLZwkw3Mz+VyPthaG9XNIBSWdQiqJx+8cTmdnt+BHdFZgATMGDzPeBOWn3Jgf1eAC6yMweLzC+CH4PHAOcb2Zba5gnl7eSss8GhuGLqBuexZoJ/BBYLOnoCrycg3+zxWb2fmmJWmJ366qwbbVIY1dAkqWoyleN0pwHAscHpl+VdLqZvVID7b/ju9tp+I76CLAFOAXfVVfhcVYzt0HSVcDNQANwF7AeP6VuAeZLqjOzq/IYkTQJuAL4Fx5o1gxJg/CddHpWKrmKeSryVkZ2M1NqmjeBCyVtDrSm4SniLEwM7cwy8mShjXRV2LbiEyjZ5XuQje6pcVXBzDaY2UO4K9aLprx9KdohVjoDP+HW40r4DZ7RGYK7JwBxtukk4FbgETO73MzWmNmWsJDPxAPdK0JSowUkXYynMVcAQ81s464lr4zIHVlJU4BaZp6KvNUqewaS4PvEHH6OwDfMD4BFVYqTibbSVTW2FZ9A74R2QA7dJGuWF6cUgpmtk7QCqJPUO2Q5StE2s+3A9PC3E8H3rsOLt29Fj04PbYtUqZltkfQSbkzHkAogJU3Ga1NvAsMKunpFsC9Ncm+T0hs+ALMkzcID5snphwV5Ky17DhIaeVnZ3ZE8aCtdFbateAElih0uqXMqX74fcEJ46YWKIhbDQaFNFNvatMcBewFzQ+oxwZ6hzUvXJv1fxZ0h+K7H6xy/iFObrYAv8YJdFgbiBv1PfJPJuilQlLdSslfA4NC2WGyS9sK/QSP5spVBW+mqEprZ1s4FZGarJS3FXayL8eruTtr4TjPTzHbm28PtgT2A1bGhSjoML76tTwnQGbgRL5g+l1zPKUM7zNfdzD5P9f0UV9JmvDAY4x941XuipJlm9mH03mn4Qt0GPBf1Xx/meRlPftTstsUIQfBvs55JmoYbxdz09ZQSvJWR/Ujgowx3sC8eQ0F24XUMnrxZ2JrJgzbUVWHbSicRLsIV2CBpGPA2fv1hKO4+XZsa/yReoOuHF0ETnAr8QdIzwGrcZzwQrzT3x/3KCTXSBlgmaSt+HG/C7yyNwHeq0WaW3h3vx2sdpwBvS3oo8HI47uJ0AqZYuKcn6bygqG9wA5yU4TasNbM5cUeoZI8KP5OawmBJybiPzSyval4IJXirSvaAMcAUScvxqvwmPIgeie/Ci2h+nSdBkjzIunmQlmMU7U9XUNC2mi2gcBIcS9OFzhH4ZcMG/EJn0d33CVx5J+AXBHvileKVeBDYkBG4laF9P3AunjHZG/gPXm+oN7O16cFm1ihpBH7KnYv7/PsAG3FjaDCzpdErSR2gC56Gz8LTRNeFAurwqx4x+tNUQ1hH/rWToqiKtxKyg7vWh+I7+2DcE/gUd5PmAfPSNwhCgXMIxZMHdbQzXQUUsq1OHf+doQMdKI9vAbFGlzCZ9XyAAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle 0.309821428571429$"
      ],
      "text/plain": [
       "0.3098214285714286"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "34.7/112"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle -4.75448803876352$"
      ],
      "text/plain": [
       "-4.75448803876352"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(answer[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADwAAAAPCAYAAAC4EqxxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAABtElEQVR4nOXWvWsVURAF8F80gkIKrUUsBEGx0UJEYqN/g1YJKPjRiYWVoON0NhZiZWIQFVsro5WNCGnTiUJATLSzU4yIeRa7KV7Y59vdtw8ET3PvMmeGOffj7J3o9Xr+J0yOs3hmzuJJ+XkpIh7WyDmPR0NoGxGxvQ1/bIIzcx/u4xumGqQuIwfETuE0XrXlj0VwZk4oVv0rnuN63dyIWFaIqKq7VE7n2vK31W2kIa4qVvYCvndRMDOP4AQ+Y7Etv3PBmXkId3AvIt50WPpKOS5ExO+2/E4FZ+YknuITbnRYdxdmsIE6xjeQ3/UdvoWjmI6IHx3WPYfdWIyI1VH4fYIz8yP2N2jkWUTMlLnHFbt6NyKW/p7WGJfL8cGo/K07vIL1Bo18oe8of8DNBvlDkZmHcRJreDkqv09wRJxp2dcUDpbz9czK3+J8Zs4rzOxag9qdmNUmurrDP7EwIHZMca/f4j1qH/fM3IlZhfkMqt+I34ng0qAuDmjitkLw46qnZWYewA6sRMSvLeGz2IMXNc1qKH9cD48meI132FsR2zSfuYpYFYby/wXBlSgfMNPqm1Ut/h/8b6g5NUBv2AAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle -4.77$"
      ],
      "text/plain": [
       "-4.77"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.6-0.31*27"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\frac{\\log{\\left(7 \\right)}}{7} + \\frac{\\log{\\left(11 \\right)}}{7} + \\frac{\\log{\\left(21 \\right)}}{7} + \\frac{\\log{\\left(24 \\right)}}{7} + \\frac{\\log{\\left(66 \\right)}}{7} + \\frac{\\log{\\left(115 \\right)}}{7} + \\frac{\\log{\\left(325 \\right)}}{7}$"
      ],
      "text/plain": [
       "log(7)   log(11)   log(21)   log(24)   log(66)   log(115)   log(325)\n",
       "────── + ─────── + ─────── + ─────── + ─────── + ──────── + ────────\n",
       "  7         7         7         7         7         7          7    "
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 3.61211339180635$"
      ],
      "text/plain": [
       "3.61211339180635"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=[0.1,0.05,0.01,0.005,0.001]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.70554345409542\n",
      "3.84145882069412\n",
      "6.63489660102121\n",
      "7.87943857662242\n",
      "10.8275661706627\n"
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "    print(chi_squared_of_error_probability(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "chi=ChiSquaredTest(Matrix([[33,10],[38,7]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\frac{1953688}{2335545}$"
      ],
      "text/plain": [
       "1953688\n",
       "───────\n",
       "2335545"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chi.chi_squared_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 0.83650197277295$"
      ],
      "text/plain": [
       "0.836501972772950"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "chi=ChiSquaredTest(Matrix([[120,75],[80,125]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAG4AAAASCAYAAAC6u+tBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAE+ElEQVR4nO2Zb8yPVRjHP48sSmgRVpp6nqU/KpKS1RQaCvGIN01rXihTo1BJbV/fNi3VFNHUm0y8aRatwhBLodrSssZK/q2/T0WZkVnRi3N+2/3cv9/t8btvrVm+22/nua8/57rOuc65znXOU3P8+HHO4PRD8+SH7VHAbUAPoDvQGlgiaUxWB7Y7A88Ag4F2wE/AcsCSfs/QGQJMAq5O6HwOzJa0+VTYyeNX1OsI/AjMlzQx0vYAXTJUGiR1qtDPLKAX0BVoD/wJ7I0+zJO0r4h8s5S9p4GHCYH7IWtwCWN1hAkfC3wGvATsIgRls+12GQN6D+gJrALmAFuA4cBG22WLpFo7efxKYDhhXpal6AcAV/i9mNHPo0ArYE0c4xLgL2AGsNX2JUXkm1dQ/h74lrDz1p9ggACvAh2AiZJeKRFtz459zQTGJ+idgKlAA3CdpF8SvH7AOsIuWVzETg75JOqBfcCGFP0PSTMydCqhjaQjaaLtmcB04ElgQl75RjtO0npJOyQ1efDZrgUGAnuA+Sm2gEPAfbZbJehdos1Pk0Er2QYOAhcWsZPTr5KttkB/4F1Jf1ce+cmhUhAi3ort5UXk06myGvSP7WpJx1JOHAQ2AucCNydYO4CjwE222yd1bPclnKlrC9rJ41cJQ4Czgbcr8FrYHmN7uu1JtvvZPquCXFMYFtutReTTqbIaXBHbbzL4OwgrvyvwAYCk/bafAGYD22wvJ6SlOuBuQn5/sKCdqv1KoJ6wI9dU0OsEvJmi7bY9VtKHGbawPRU4D2hLKD5uJQThuSLyRXZc29geyOCX6OcniZJeBkYSFs04YBowGvgOWJhOoTns5PLLdktCBbqyQtp6AxhACF4r4FrgNeBSYKXt7hm2IJzpAh4hBGEVMFDSr0XkiwSuKdTEttF5aftxYCmwkLDTWgE3EKq+JbafPxV2csgPJKz0dDWJJEtaJ6lB0mFJX0kaT8gc5xAqv4qQ1ElSDSHoI4Fa4AvbPYvIF0mVpZXbNoPfJiWH7duBWcAySZMTslts1xPS2xTbCyTtymmnar8i6gnn7/sZepWwAJgC9G1KUFIDsMz2FsI4FwHX5JUvsuO+jm3XDH6pCkqeNUNjW3bNkHSYcOdqBlxfwE7VfsUiYxiwTlJWiq2EUlovq1CzIGkvsA3oli7QqpEvErjS5A+03agf262BWwi3/08SrBaxbVTyJ1CiHy1gJ49ffQmvK2Vpsgn0ie2uE0qV46LYnuyVo0w+d+Ak7QRWEw7oh1JsE1bhIkmHEvSPYvuA7YsbKdh3Eib1CLApr52cfo0EjgHvpMdpu5vtCyrQuwDz4ufiFO/K+NiQ1mkWL9QdgE2lp7dq5aH8rXIEMCJ+ljrqY3th/Ps3SVMTKhMIkzzX9gBgO9Ab6EdIRU+lfFlKuKfdAWy3vQz4GbiKkEZrgGnpd7kcdqqVHxEnpoFyjAam2V4P7CY8EtQR7nwtgRWUP3sNBl6wvQHYSbjydCS8RtXGMY8rIF+243oA98ffoEirTdBGJYXj6u5FqBB7Ew7qOmAu0CcdgHghvovw7LSNUBBMIVyGVwCDJM1J+ZTHzknL274R6Ex2mlwfeZcB9wKTCRP6cZyToZKOpnTWAq8T0u9I4DHgHmA/Ydd3k7StgDw1//d/69h+lvAOWCtp93/tz8ni37zHnS6oB748nYIGZ3bcaYt/AM+sbucAn2hDAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle \\frac{10800}{533}$"
      ],
      "text/plain": [
       "10800\n",
       "─────\n",
       " 533 "
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chi.chi_squared_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 20.2626641651032$"
      ],
      "text/plain": [
       "20.2626641651032"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}120 & 75 & 195\\\\80 & 125 & 205\\\\200 & 200 & 400\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "⎡120  75   195⎤\n",
       "⎢             ⎥\n",
       "⎢80   125  205⎥\n",
       "⎢             ⎥\n",
       "⎣200  200  400⎦"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chi.expand_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "chi=ChiSquaredTest(Matrix([[10,40],[40,10]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAQCAYAAAAI0W+oAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAACG0lEQVR4nL3UTYjWVRQG8J9DCoNlWMNMiIMmGIGKIJkw+IU4JqSLtPZuBsJFlIwLTTwdJPADqaBVS8GFKCiIoTirWTQ4iyEVBKP82GmmM+JiXKjj4n9feN+/79gsorN57j33nPPcc+9z76ypqSn/h73RPMnMI/gIH6ALk7iLc/g5Ih62K5KZ6/A1+vAOHuE6foyIX6GjlvMN5uIyfsJJPMN3uJaZvW1IDmAY63ERx3Ee87GxbUeYFxFP2xT7HvuxD7ub/F/gEIawIyKe1PJmN8azZnJHmbkSv2MoIvqLrwN/ogeLI+LB62rUO5rOthe81uTrw/s4g/HM/BTL8RSjETHyr0SZOYg38bZKHGsLyeGmsNUF72MMK2o1hvF5o9PpOhpUHUnDLmJX7Xi6C36J29iMK1ikEsQnOK0I4rV3lJk9qiM6jLewLSLGytpR7MULrIqIq015nfgDC9EXESN1ebdYRNyPiLPYgndxoml5vOCtZpKSN4lLZfoxr76j6Qjv4gaWZWZXcd8sODFNWmMjnTMmKrag4POCw6rHvDQz57SJX17wTgtRZn6Yme/VozOzozzYbvwWEeMQEf/glEqZB2s5/SoxPFYJqUV1W3GsyPIvPFQpbwOW4B4GavvYgzX4NjPXY1Slus9K5wMRMdHSkeob+UV16TtUitqp+iATyyLiRjNLRPxdiH5AL77CJlzAuog43Yid0Rf0X9hLzf6yQ4BIHlEAAAAASUVORK5CYII=",
      "text/latex": [
       "$\\displaystyle 36$"
      ],
      "text/plain": [
       "36"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chi.chi_squared_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmd={1:1/S(2),2:(1/S(2))**2,4:(1/S(2))**4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\left\\{ 1 : \\frac{1}{2}, \\  2 : \\frac{1}{4}, \\  4 : \\frac{1}{16}\\right\\}$"
      ],
      "text/plain": [
       "{1: 1/2, 2: 1/4, 4: 1/16}"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pmd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmd[5]=3/S(16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\left\\{ 1 : \\frac{1}{2}, \\  2 : \\frac{1}{4}, \\  4 : \\frac{1}{16}, \\  5 : \\frac{3}{16}\\right\\}$"
      ],
      "text/plain": [
       "{1: 1/2, 2: 1/4, 4: 1/16, 5: 3/16}"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pmd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=FiniteRV(\"X\",pmd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADoAAAASCAYAAAAKRM1zAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAADvUlEQVR4nOXXW6hWVRAH8J9aZlgZJiURWYYlaGhQ2TE7RRcTLOpIvoQQPRjRQ2T50I3GIbpRkERB9VJkBV3IgkpD6ZBEhg+G3SApLxTVMdMj2oVu9rD2ie3n/s75RNCH/rCZvWfNmjX/PWvPmj1s7969/g84ov6QmY/gXJyJcfgNW/EmnoyIn1vst2BCG999ETG+3cKZeRK+x1MRcWuluw4XYzqm4Vi8FBELBiORmRfhNszEWOzAZ1gaEe/uRxSLsB6rsA2jcQGW4KbMvCAivm2ZswtLG9bfM1hwuAbDsbymu1chuAffYfIQPmTmvbgf2/E2flCSdA4uQSPR4yLi9wZnD+Bu3IVbWob7I2LJUAE1oAc/Y01Nt0gh+LWS2d7BHGTmfIXkasyLiN0t40cO3O9DtIlkhVcVopM6ojAEMnMMLsXLEfF3bf3ems1QPobjEfyK61tJVv7+HLhvzWg7XF3JTxvGjsrMBTgVv1Q2a+oEGjAXI/FGh+s3YSZOx+vYmZlzMRW/Y11ErK0bNxLNzMU4BmOU4jSrIvBwg/l4LGvRbc7MGyPigzZB9igvZVUnjNrgvEr2KXXl7PpgZq7BdRHxE6UYNGExQqlks7ASswcm1fAcLlPIjq4WewanYUVmTmt1nJmjMAcrBvlUOsGJlbwZR+NypUpPxXvoxmsDxo0ZHTgWqiNgppLJTzLzqohYX7Nr/ZA+x82ZuQd3KNW6p8VmtrJbljs4jKjkMCVzG6rnLzKzBxtxcWZ2RcTadhkFEdEXEcur4E7ACx0G8XQluxvGevAH3unQVzvsrOSmGkkQEb8pWYXzab9190FEbMWXmJKZ4zqYsq2So+vKzByhFLb3I2JXJ2sPgq8q2d9mfOBFHE2HRCucXMnBqukAuiq5qUXfreyMg922lPP3L0zKzJEN41MruYUa0cycnJn7tWyZObxqGE7ERxGxs9JPycyxDfYT8GT1+GLL8Dz8g7cOhFETImI7XlFOhvtaYrgCVypd20r2LUZz8GhVlr9RupaTlA5lIn7Ewpr9fNyZmb3YjN04QzkjRymt12Mt8V2rvKy+puAz89rKhlLJoSszn6/ut0fE4tqU2zED92RmN9YpvXePsvMWRkR/K9HVeBYXKv3m8cpZt1E5J5+IiB01+16cpfSUXcr32I8PK/tlEfHfr1FmnodT8HgTyQrTcUOLbmJ1UX4w/iMaEdsyc4bSI/cofflupdA9FBEfD9gOO1S/aZn5oNIrT4yIzYdk0RoOpBgdLHqw4XCQ5BBm9HDjX7CJOXnxqer6AAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle \\frac{35}{16}$"
      ],
      "text/plain": [
       "35\n",
       "──\n",
       "16"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1=1/S(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "p2=1/S(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "p3=1/S(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAB8AAAASCAYAAACjMAXnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAACMklEQVR4nMXVX8jOZxgH8M9rYoUcIIpS7444MH+ylOZf2msYHtmZ2hFOFoa2KXV1OVB2IO/BaocO9p7Ju+XPiCgaUVNOHIxQbEOmlkiKdwe/+6mf54l4HuWqX3f3dV+/63t/v9d133fP0NCQ92XD65PMXIeFmImPMQYDEbH+dUkycyL+xo8Rsbn4VmALpmMc/sEf2BcRF2BYS55d+LqA//UWJFaXXIMFeC+OYDaOox+XS9zvmbm+jTm+wR1cVylw5g3BG/gXZzNzEnbgHmZExP1mUGYuxmnsxs8vMY+IMxFxLSLeuBEycyyW4HBEPMdUlQoX68DN/HiECbTL3omtwAgcKvNreIZPMnN8y0YXqProFO2yd2INPMZJiIiHmfkd9uFqZv6iKslHWFXiNtEl88z8EMvwW0Q8bfojYj/WqshtwPf4ErdxoFmObmX/DKOVLq9t6lscxAEV41GYgxsYyMwf6F72hqq+R2vAi7AXgxGxrRZ7OTMb+BPbM/Onjpln5gf4Aqcj4r/a0soyth3TiHiCSyrFZ3Uj+wLVzTXY4h9Zxgmv+K/pf9YN+Fq8wK8t/nNl3JiZk+sLmfk55uMpzvfUH5bMXIM1ZToJfaomaSZ8EBE7Suxt3IqIT1sAhuEElqoulEHcxTRVSXqwNSL6W5nPxFfl6yu+3ppvXQGYiynaJRcRL7BcdVVfVTXldszDMfRFRD/0dPKkZuYe7ERvRNx86wTFOq15A1e6AaZD5u/K/gcRV7wgVF4f8wAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle \\frac{1}{8}$"
      ],
      "text/plain": [
       "1/8"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1*(p2+p3)-2*p1*p2*p3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pro(n):\n",
    "    m=n-1\n",
    "    ps=[p1,p2,p3]\n",
    "    return ps[m]*(sum(ps)-ps[m])-2*prod(ps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/8\n",
      "1/6\n",
      "5/24\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,4):\n",
    "    print(pro(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, -3, -5, -7, -9, -11, -13]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "20-data_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9, 11, 13]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_x-20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1/2, 3/4]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Data([2,3])/S(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{n^{3}}{3} + \\frac{n^{2}}{2} + \\frac{n}{6}$"
      ],
      "text/plain": [
       "n**3/3 + n**2/2 + n/6"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation(n**2,(n,1,n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{n \\left(n + 1\\right) \\left(2 n + 1\\right)}{6}$"
      ],
      "text/plain": [
       "n*(n + 1)*(2*n + 1)/6"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{3^{- n} \\left(- 3 \\cdot 3^{n} + 2 n + 3\\right)}{2}$"
      ],
      "text/plain": [
       "-(-3*3**n + 2*n + 3)/(2*3**n)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation(2*n/3**n,(n,1,n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{3}{2} - 3^{- n} n - \\frac{3 \\cdot 3^{- n}}{2}$"
      ],
      "text/plain": [
       "3/2 - n/3**n - 3/(2*3**n)"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=Function(\"f\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=f(n)*(f(n+2)-f(n+1))-f(n+1)*(f(n)-f(n-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\left(f{\\left(n \\right)} - f{\\left(n - 1 \\right)}\\right) f{\\left(n + 1 \\right)} + \\left(- f{\\left(n + 1 \\right)} + f{\\left(n + 2 \\right)}\\right) f{\\left(n \\right)}$"
      ],
      "text/plain": [
       "-(f(n) - f(n - 1))*f(n + 1) + (-f(n + 1) + f(n + 2))*f(n)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{- 2 f{\\left(n \\right)} f{\\left(n + 1 \\right)} + f{\\left(n \\right)} f{\\left(n + 2 \\right)} + f{\\left(n - 1 \\right)} f{\\left(n + 1 \\right)}}{f{\\left(n \\right)} f{\\left(n + 1 \\right)}}$"
      ],
      "text/plain": [
       "(-2*f(n)*f(n + 1) + f(n)*f(n + 2) + f(n - 1)*f(n + 1))/(f(n)*f(n + 1))"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(_)/(f(n)*f(n+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -2 + \\frac{f{\\left(n + 2 \\right)}}{f{\\left(n + 1 \\right)}} + \\frac{f{\\left(n - 1 \\right)}}{f{\\left(n \\right)}}$"
      ],
      "text/plain": [
       "-2 + f(n + 2)/f(n + 1) + f(n - 1)/f(n)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 2 f{\\left(n \\right)} f{\\left(n + 1 \\right)} + f{\\left(n \\right)} f{\\left(n + 2 \\right)} + f{\\left(n - 1 \\right)} f{\\left(n + 1 \\right)}$"
      ],
      "text/plain": [
       "-2*f(n)*f(n + 1) + f(n)*f(n + 2) + f(n - 1)*f(n + 1)"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr1=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 2 f{\\left(n \\right)} f{\\left(n + 1 \\right)} + f{\\left(n \\right)} f{\\left(n + 2 \\right)} + f{\\left(n - 1 \\right)} f{\\left(n + 1 \\right)}$"
      ],
      "text/plain": [
       "-2*f(n)*f(n + 1) + f(n)*f(n + 2) + f(n - 1)*f(n + 1)"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 f{\\left(n \\right)} f{\\left(n + 1 \\right)} - f{\\left(n - 1 \\right)} f{\\left(n + 1 \\right)} - 2 f{\\left(n + 1 \\right)} f{\\left(n + 2 \\right)} + f{\\left(n + 1 \\right)} f{\\left(n + 3 \\right)}$"
      ],
      "text/plain": [
       "2*f(n)*f(n + 1) - f(n - 1)*f(n + 1) - 2*f(n + 1)*f(n + 2) + f(n + 1)*f(n + 3)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr1.subs(n,n+1)-expr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\left(- 2 f{\\left(n \\right)} + f{\\left(n - 1 \\right)} + 2 f{\\left(n + 2 \\right)} - f{\\left(n + 3 \\right)}\\right) f{\\left(n + 1 \\right)}$"
      ],
      "text/plain": [
       "-(-2*f(n) + f(n - 1) + 2*f(n + 2) - f(n + 3))*f(n + 1)"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 2 f{\\left(n \\right)} + f{\\left(n - 1 \\right)} + 2 f{\\left(n + 2 \\right)} - f{\\left(n + 3 \\right)}$"
      ],
      "text/plain": [
       "-2*f(n) + f(n - 1) + 2*f(n + 2) - f(n + 3)"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.args[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "def an(first):\n",
    "    an=S(first)\n",
    "    while True:\n",
    "        an=2*an/(1+an)\n",
    "        yield an"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/3\n",
      "4/5\n",
      "8/9\n",
      "16/17\n",
      "32/33\n",
      "64/65\n"
     ]
    }
   ],
   "source": [
    "count=0\n",
    "for i in an(1/S(2)):\n",
    "    if count>5:\n",
    "        break\n",
    "    count+=1\n",
    "    print(S(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{3 \\cdot \\left(2 \\cdot 3^{n} n - 3^{n} + 1\\right)}{4}$"
      ],
      "text/plain": [
       "3*(2*3**n*n - 3**n + 1)/4"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation(n*3**n,(n,1,n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "class an():\n",
    "    def __init__(self,count):\n",
    "        self.a1=1\n",
    "        self.a2=2\n",
    "        self.count=count\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "        match self.count:\n",
    "            case 0:\n",
    "                \n",
    "                answer= self.a1\n",
    "            case 1:\n",
    "                answer= self.a2\n",
    "            case _:\n",
    "                answer= an(self.count-1).__next__()-an(self.count-2).__next__()\n",
    "        self.count+=1\n",
    "        return answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 : 1\n",
      "2 : 2\n",
      "3 : 1\n",
      "4 : -1\n",
      "5 : -2\n",
      "6 : -1\n",
      "7 : 1\n",
      "8 : 2\n",
      "9 : 1\n",
      "10 : -1\n",
      "11 : -2\n"
     ]
    }
   ],
   "source": [
    "count=0\n",
    "for i in an(0):\n",
    "    if(count>10):\n",
    "        break\n",
    "    count+=1\n",
    "    print(\"%d : %d\" % (count,i))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "class fn():\n",
    "    def __init__(self,f,value):\n",
    "        self.f=f\n",
    "        self.value=value\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "        f=self.f\n",
    "        x=list(f.atoms(Symbol))[0]\n",
    "        old=self.value\n",
    "        self.value=old-f.subs(x,old)/diff(f,x).subs(x,old)\n",
    "        return self.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 ,1/2\n",
      "3 ,1/4\n",
      "4 ,1/8\n",
      "5 ,1/16\n",
      "6 ,1/32\n",
      "7 ,1/64\n",
      "8 ,1/128\n",
      "9 ,1/256\n",
      "10 ,1/512\n"
     ]
    }
   ],
   "source": [
    "count=2\n",
    "for i in fn(x**2,1):\n",
    "    print(\"%d ,%s\"%(count,i))\n",
    "    count+=1\n",
    "    if(count>10):\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display,Math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{2}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(Math(test()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{2}$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Math(test())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b=symbols(\"a,b\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "hyper=Hyperbola((0,0),a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHQAAAAkCAYAAABYFB7QAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAEoklEQVR4nO3aa6hlcxjH8c8Zl3EtGaSQolHEOITcxq3ILUauYTJFyaUYDUnDM09MFLkkL5gXzhijRLxwSRRyG0KOmZBccpdhTF7I3Xix1hkzxz777H3OOmft2du3drv9X+v/X7/ds55nPc9/PX1r1qzRq2TmLliCHfAHMiIeq1fV+JhSt4Ca+RNXRMReOBZ3ZeYWNWsaF3297KHDyczlODkivqhbSyNaiSi97qFrycwDsAm+rFtLE0aNKP97KDJzGl7GRRHxWt16WqVRRNm4Rj2TQmZ+hdsj4vZ1xvrxBvbDJ3gcN29gxmwYUbreoFiGA4eN3YFF+AAP4fmIWDLZwsZKGVEewIURsV6I7RWDXjr0IzNPx744A4fhbCzPzFnlKbMjYsVki2yVzJyqSUTp+mdoZh6KVzENP+N93B0Rd9apqxGZeSYexB4R8Xk5dhdOxKH4QRFRPoyIBY3W6IUs9238jgMwV5Hu31OropF5FCswHzJzHs7B8RHxvX8jyqzMHCw/+6y7QKUempln4Ej0K8La1lgaEedXdpGx6Xodb+ICnBsRT9appxmZeRyewvW4DsdExFutzq/aQ+fjcoVBv6547fGwDJdhWScbEyLiWcXNdxPOaseYVJ8UzcVX+FjhqS9UvP5YGcTfuGqiL5SZc3A/jo6IF8cw/xhFdJuCle3Or9SgEbHWgJlZ5dLj5XzcGxHv1S2kGZm5Lx5TZOWnYSFOaGeNri1bMnMKtseF2Btn1auoOZm5K57GrRGxODPfwWBmzoyIl1tdp5uz3CPwLWbj9IhYXbOeEcnMbfEMnoyIhRARyxVZ783trNW1Hlo+vzaIGzYifsSeDcbbjirrGTQzP8OubcyvvCTpBA2tMorWFxrkEYsjYs5EahruoZ/g1zbmf1Ohlk7S0Cp3YpthY/04FYvx2bBjgxOsZ+K2/jLzKEXZUvvGwmQy3rJlvHTtMxQys5K7NSL6qlinGVVp7WqDtmKITmkUq0prpVlgZs7KzIHMHMC15fAhQ2OZeVuV16uIDalRbFStVXtov2IDfF12Kz/wOeZVfM1RycyFOCgijh1+LCK+VdSrImJlZq7Gdui4RrFWtFa99bcAC6pcsyL68e5oJ1XRKBYRAxgY6/xWGUnrBlF4V0C/UUqGZm0dnUYzrb3QsbC94q3FeYp93UPwES6OiNfLc6biOSyqu7coM29QtMfshl/wBC6NiF/L4021dnWWW7Jf+T1P8XrvO0WT2MOZuTv+UoTI2hvFMrMPG+ESxWvI6YoNiitxS3l8QBOtveCh1+BG6/fpzFA8U6djR7yE5etM65hGscy8D5tGxJzMPNwoWnvFQx8dMmbJz+X3lIh4RYfkEmWdeTWOxk7YFFNxC7SitSP+yATTj3eGje2Pn/DppKsZgTLReVMRMeZhpqKf+DctZOhDdLWHlkX3dEV6PzTWhyuwJCL+rEtbA07CZjh7KHMt94W39N8bckS62qCYgTWYnZnPY5WiTt4Zp9SoqxGrsJWiRXOFovXkOm1Gkm4Puf2K13Hz8YgimdgcB5cvlTuJp3GvIqt9TRFZlmKwnbq467PcXqPbPbTn+Ad2wOPPkLWKWwAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle -1 - \\frac{y^{2}}{b^{2}} + \\frac{x^{2}}{a^{2}}$"
      ],
      "text/plain": [
       "      2    2\n",
       "     y    x \n",
       "-1 - ── + ──\n",
       "      2    2\n",
       "     b    a "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hyper.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "F1,F2=hyper.foci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(- \\sqrt{a^{2} + b^{2}}, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(-sqrt(a**2 + b**2), 0)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(F1,slope=k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMsAAAAfCAYAAABJVDkKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAHf0lEQVR4nO2ceYwW9RnHP7SIpB5BTfDERluL1iK0aMCjBCVKo6W0tLZKgGI0tVrjgWjEoE+/jReXWbXQGFPlsOllTBeaWLS1pqCFsiig0vWKeAQNEhVF8d7+8fyGzo7vuzPv+87su5udT7KZ3Znf8Z3j+f2e5/nNbL+Ojg5KSkrS+UKzBZSU9Bb6N1tAX0DSIOCtZuvojZhZv2ZriCiNpXuYCPzYzP7cbCEl9VO6Yd3DeOBvzRZR0hilsRSMpAHAADN7t9laShqjNJbiOQ14pNkiShqnNJbimQAsb7aIksYpA/ziGWJmL+fRkKRZwCRgKPAhsAaYZWZP5dF+0fR2/eXMUiCSvglsyLHJscAi4CTcvfsE+Luk/XPso0jG0ov1lzNLsXwPWJFXY2Y2Pv63pKnADuDkPPvJiqSLgYXA+WZ2d1r5nqa/VnI3FkkzgAXAZDP7fd7tF03O+kcCv2pcVVX2wb2DNwvsoyu+Fbbr66zfbP01UYQb1ugFbDa56Jd0KLDVzIp8+a4Fd/PWFNhHV4wEPgCerrN+C83VXxNFGcu7wHMFtN0d1KRfUrVrOIECXQtJ84AxwNlm9mkd9adL6pA0ts7+9wSOBTaZ2Sd11G9IfzPI1Q2TtBee6VhV8IhaCLXqlzQBmC/pGDP7LHF4HDA1QxuTgbOAE4CD8aD3eWCRmd1Tpc4CYApwqpk9n9ZHQQwD9gDWSxoBXIcH8AOBR4EZ1bJceeuXNB24J7T3SKPtVSPvmGUEPlt1cmEk7QcsxgPe24CrzOxjSQ8CpwM/NLP7Y+X74Sf/U2COmV2Ts85qjCCjfmA4/nAchWd3VsfK7wV8amYfdNWZpH2AJUAbsArYBgzG3yW7W9JgM5uTqHM78BP8wdhc32nmwsiw/TJuHA8AvwVOxO/pw5K+ZmZvxyv1IP1IuhKYD8w0swUVjg8FNgFrzWxM3sYSXcDdD5ukUcAfgf3xKfe+WPmrgMeBGyS1xqbj+bih3NWNhgK16W8D2iSNxo1odayd8cCDGfrrwNdhXo/vlDQbeBY4D5gT278IH5G/D7wp6aBwaKeZ7cxygjkSXatRwClm9kR0QNJSfFa9GLgptr8n6Yf/37PRVY7fAXwRuATyj1k6Bcchs7QKeAc4PmEomNlGYBlwDMFlkXQtMAP4E/DznPWlUZP+wF/wmSDOWcBf0zozs51JQwn7XwO24gYa5yI8g/QP4LXYz8y0vgogulZXxw0lsDBshyX29yT94AP1LtzgOyHpbHyGXGhmmyB/NywKjrdLasVH3CXARWa2q0qd2fi0/EtJewM3AiuBqRXigKKpR38rMFfS0WbWHgL+A8xsW1pnwb27BDeuocC+dB7AOj2E9X7bIWkL7i5V4p+SkvuWmNn0LtrbAzeEl4ClFYpEA8DA+M6e9G0KQAgF1gFjJB1iZlthtxt9K+4WXx+V72QsKRe1Er8zsymh7kB8htiGj8wHAj8zs7tSBL8qqQW4Bp/2HgMmmdlHaZ03ordCW/Xqf1bSM7hhteM++9oM2o/DXbUDgf8Af8DXGz4GjgCmARuznVYqLcCgxL4R+Iy4BNiSOLYhpb1hwABgRZVMWHRPXsouMRt5Gz4eb43BXbEobr4eOAw4z8x2RAWTM8sLeN48K1tjvw8P7e0JHALcm/agxXgj9vv5ZvZ+xnqN6E3SiP5W/MGbixtNpdE2yTL8Af5cBkdStJDZlrH/LjGzluS+kEGaCCyuI4MUuWBbqhz/QdhmidtqpYV8Df/RsB0F3C/paOAK4N+hvd10MhYzG5dJbmWigO9K4EfAFEnrK92oOJLOxQP614GDgMtw3zaVBvUmqUt/oBWYKWkw8HUz63KRTtIQ4DhgZQVDGYQH9tBzF3aja/W5d7okHQxciK9T5W4sBRj+Y3iiJQryf40H9b9ILh/kGeBHo00bcA5+oxdImlStgqQzcet9Gn942oELgnV3NzXrj7EG2A5cjq+RpBHNhkcG/x8ASQfgmbfD8PWWDVmEN4HIWM4N/j0AIeZcis/Ol9azWNndmNlbwH+B48Oa1zjgzgpJi9yNZRfQbmbvAd8FXgHulXRisrCkU4D7gFeBM8zsDXxhqz9wS466slKT/jghEbECz+qkrtqHc30YX6NZK2mupGXAM3jm7TNgc9o6TTOQ1B+PWZ4APgI2SJoX1k/a8YftCjPrTZ9Rrwa+BNyJD3qzKxXKxVjCp7PfAJ6M1kpCSvRM/LuF5ZK+Gis/HE+t7gBOD6lSQmq2DZgo6dt5aCtCfxWWA+8B/8rY7Tl43DIEdzu/gqfMb8LvSy7xSgEci2e52nDDeBJ3u6bjHsJpZnZ709TVRxS37I1/X1Pxxc68UsfRqw/JVOfm4MasBB4II/Sg8HcHMN7MXki0NQt4CJhH9cWivMms38y2V2njIWBuVtcjzC7TqhwuPMVqZovxtxJqrbeRzvqyuKk9nRfDdh3+FkJF+pX/kbKkryNpOb7WNdrM1lUrV34pWdKnCUH9BOA3XRkKlF9KlvRBJB0OTMbjxGl4rHV1Wr3SWEr6It8BbgbextfILs+yEF7GLCUlGfkfKcsAia8avH4AAAAASUVORK5CYII=",
      "text/latex": [
       "$\\displaystyle - k x - k \\sqrt{a^{2} + b^{2}} + y$"
      ],
      "text/plain": [
       "            _________    \n",
       "           ╱  2    2     \n",
       "-k⋅x - k⋅╲╱  a  + b   + y"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B=Intersection(hyper,l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\sqrt{\\frac{4 a^{2} b^{4} k^{2} \\left(k^{2} + 1\\right)}{\\left(a^{2} k^{2} - b^{2}\\right)^{2}} + \\left(- \\frac{- \\frac{a b^{2} k \\sqrt{k^{2} + 1}}{a^{2} k^{2} - b^{2}} + \\frac{b^{2} k \\sqrt{a^{2} + b^{2}}}{a^{2} k^{2} - b^{2}} + k \\sqrt{a^{2} + b^{2}}}{k} + \\frac{\\frac{a b^{2} k \\sqrt{k^{2} + 1}}{a^{2} k^{2} - b^{2}} + \\frac{b^{2} k \\sqrt{a^{2} + b^{2}}}{a^{2} k^{2} - b^{2}} + k \\sqrt{a^{2} + b^{2}}}{k}\\right)^{2}}$"
      ],
      "text/plain": [
       "            __________________________________________________________________\n",
       "           ╱                                                                  \n",
       "          ╱                        ⎛              ________           _________\n",
       "         ╱                         ⎜       2     ╱  2         2     ╱  2    2 \n",
       "        ╱                          ⎜    a⋅b ⋅k⋅╲╱  k  + 1    b ⋅k⋅╲╱  a  + b  \n",
       "       ╱                           ⎜  - ────────────────── + ─────────────────\n",
       "      ╱         2  4  2 ⎛ 2    ⎞   ⎜         2  2    2            2  2    2   \n",
       "     ╱       4⋅a ⋅b ⋅k ⋅⎝k  + 1⎠   ⎜        a ⋅k  - b            a ⋅k  - b    \n",
       "    ╱        ─────────────────── + ⎜- ────────────────────────────────────────\n",
       "   ╱                        2      ⎝                              k           \n",
       "  ╱             ⎛ 2  2    2⎞                                                  \n",
       "╲╱              ⎝a ⋅k  - b ⎠                                                  \n",
       "\n",
       "______________________________________________________________________________\n",
       "                                                                            2 \n",
       "                              ________           _________                 ⎞  \n",
       "        _________      2     ╱  2         2     ╱  2    2         _________⎟  \n",
       "       ╱  2    2    a⋅b ⋅k⋅╲╱  k  + 1    b ⋅k⋅╲╱  a  + b         ╱  2    2 ⎟  \n",
       " + k⋅╲╱  a  + b     ────────────────── + ───────────────── + k⋅╲╱  a  + b  ⎟  \n",
       "                         2  2    2            2  2    2                    ⎟  \n",
       "                        a ⋅k  - b            a ⋅k  - b                     ⎟  \n",
       "───────────────── + ───────────────────────────────────────────────────────⎟  \n",
       "                                               k                           ⎠  \n",
       "                                                                              \n",
       "                                                                              "
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.distance(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle 2 a b^{2} \\sqrt{\\frac{\\left(k^{2} + 1\\right)^{2}}{\\left(a^{2} k^{2} - b^{2}\\right)^{2}}}$"
      ],
      "text/plain": [
       "               _______________\n",
       "              ╱           2   \n",
       "             ╱    ⎛ 2    ⎞    \n",
       "     2      ╱     ⎝k  + 1⎠    \n",
       "2⋅a⋅b ⋅    ╱    ───────────── \n",
       "          ╱                 2 \n",
       "         ╱      ⎛ 2  2    2⎞  \n",
       "       ╲╱       ⎝a ⋅k  - b ⎠  "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "powsimp(simplify(_),force=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "AB=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKMAAAAjCAYAAAD43LpYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAHqElEQVR4nO2bf8yVZRnHP68/ol80CaO0WP6oEZZwcOpK0kUOGdMpkk5zUbTWGmVqpSvN+r5fNxfYLCQkcxngO1o/zDadJi0R0zF+SMALY5VYYAkGRrMoDZC3P+770HMeznvOc855znvO4T2fjT2c+7l/XOe813Pd13Xdz9UzMDBAJ2H7JGCMpE22xwDrgXGS/tNOc3ayHK2ipx2V0fY8YIKk6Rn69gOXSHo+fh4F/B44T9Jzda5fMmde2L4dOFfS1FrlsP0AsErSd/KUqZ04Lq+JbN8MzATGAf8FVgM3S9pSx3QF4HcZ1jwbOB74S6L5FuCxBhSx3Jx5UQA21SnHbcBK2/dJerkJsrWcY3Kc6yPAIuA84KPAQeA3tt9ax1wTgQ2VOtgeDdwPfEbSQGx7I/BZ4Id1rFl2zgxjltjuzbhEAdhYjxyS+oE/A5/IuFbHkZtllDQt+dn2LOBlYDLwcKL9m8AVwGnAK/He5yW9Gu+/A3g78Y9meyTwI+B0YKak7bZHAL8EviVpVWLZi4FDwNNp+TKsO9icuWD7bcDJwCHbjwMfAp4FPidpdaJfJTkeAq4B7s5bvnYgT8uYZmScf2+xwXYPcCwwB3g/8HFgGnBDYtwkYB+wzfZ4YC1h258cFbEHWAKskNSXWvPDwPq0Vau2bpU582JSvN5I2HLPAnYCP7V9XEY51gDn2H5Dk2RsKblZxjLMJ1i3w099VBIl+uyw/QjwvkRbAegHPgbcC1jS/MT9ycBVQL/tGbFtlqTNwCmEP3AJGdatNGdeFID9wOWSdgDY/irBhzwF2JZBjp0EP/JkoC6fuJ1pijLa/jZwAXC+pNcS7WOBm4ApwDuB1wEjgLmJ4QVgPMHvu1TSk8m5JT3N4Bb99cCrZeSpuG6VOdNz3UIIkoqMAAZs35homy7pqdTQScADRUWM/Dtej8koxyvx2rWMWbB9J8HJniJpW6J9NLAO+C1hq/orwb9bR2mEWQAeJPhGo2tc/iVgVEqerOtm5R7gZ4nP84AXgAWJthfKjCsA96XaziL41X/KuHYxGNyTsX+uxN/ycoJvfibhwd4PbAYWA4slHap3/lyV0fYCwjYzRdLW1O2LCZbrqkT0Oxt4EzFyjtHwewjKvBK43/Z2SVXTPJENwOxa160FSXsp9YP/BexNPnhp4vd6L2GLLbb1ANcDfZIOZlz+TGCnpL/VKndOXAl8H9gFPAE8Twg2ZxJ2sum2r8yaiUiTZ55xEUGJZgB7Y1QMsE/SPuDvwJuBGbY3A9MJ213SMkwEBoAtktbZPgN42Pa5kspZmzTLgXm2T5T0UmzLsm6zmUD4XrNsr4gy9QLvAi6tYZ4LgMcaESQ+iIsJBmNljcP/SJD3kaQFjK7LWoKfPxP4RT2y5WkZ58Tr46l2E374R4EfAEsJft1PgGXA2YknaSLwrKSib/R1QhL9IdvnVzsWk7TZ9hrgamBhbM6ybrMpEAKOW4GfAycCvwI+GC1tVWIEPQO4qDkiVkfSikHaX7R9D3A7Id98hDLavoawS50DnETIQ28DFklaDG16HNgItqcB3wPGJ4OnTsf2tYSAriFlbNAyVpr3JuAOYL6kL6XujSS4Ns8AW4HdwBjgMkJc8DVJ85qZ2mkJkpbbXkjYAndU699B7Ae+2GohyhHzpJ+MH8u5EQPAWEkvpsbdStj6Pw0cfcoIIGlB9V6dhaR7Wy1DBeYCHwAelbQ8fTPGDPvKtO+yvZOYJShRRtvbgXfXIMQySUftWWmnU+Xv+YTtdNtSSbNrXOM64CuEN6VmDdJnFHAtwWccB7yF0nzqBjgygHmOMknjChxx2tGlrZgPnJBqKxB8taXA9tS9jbVMbvsLwF0EP/DCcsGY7QnArwkpoLWEAHIvcAA4lbC9b4KUMkq6sBZhurQ3qWNU4HAAcxmwpJEAxvYNwHeBLQRF3D1I1z7CA3FEwGT7tvjfZyCn1I7toysk7zAk9QzlevFMfS7Bkk5N5HTT/cYScqzLyyjiCYTABcIb7fkoYzN/jPiF+gipgAOEFyceHKrxedEucjSK7W8Q3jpaD1xUJU9adPlOs328pANxjtHAjwkZj4NE96CZr5DlxUHgeklnAFOBu+Lx2lCNz4t2kaNubH+KoIivAU8B19nuTf2bXewvaQ+wgnAUusb2Hbb7gD8A/yS8I7C1+E5p26d2JO0inIUiabftfxBOMA7Xp1SqmckyPg+q1bcMlRxN5tR4PZbSd1CTPEl4J7PI1cCdhGPYOYSXKr4cr1cQ/UXoAGVMUqE+pUD9NTN5UaD++pYhQ9ISSpWllrG9hKPdWsbs4f8J8TQl7l0nbNNA1fqUumpmcqZAnfUtXQJtYRkbqU9psGYmL/nzqG8Z9rTcMuZQn9JIzUxe5FHfMuxpuWXMoT6lQP01M3lRoPH6lmFPy5Uxh/qUAvXXzKRl6aX0wShHuVev8qhvGfa0VBlzqk8pUH/NTJqFhLPTSpRLxRRovL5l2NNqy9hQfUoONTMlxGOtskdbVWTIo75l2NNqZWy0PqXRmpk8yKu+ZdjTah8mWZ+yimBhlgEbM+bgytXMrCbUzAzVUVuB0vqWfkJdc+b6li6Bo64Gpkvn0mrL2KXLYbrK2KVt+B/QgPQfOAhzRwAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle - \\frac{2 a k^{2} \\left(a^{2} + b^{2}\\right)}{a^{2} k^{2} - b^{2}} + 2 a$"
      ],
      "text/plain": [
       "       2 ⎛ 2    2⎞      \n",
       "  2⋅a⋅k ⋅⎝a  + b ⎠      \n",
       "- ──────────────── + 2⋅a\n",
       "      2  2    2         \n",
       "     a ⋅k  - b          "
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(A.x+B.x)*F2.x/a+2*a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle - \\frac{2 a b^{2} \\left(k^{2} + 1\\right)}{\\left(a k - b\\right) \\left(a k + b\\right)}$"
      ],
      "text/plain": [
       "       2 ⎛ 2    ⎞  \n",
       " -2⋅a⋅b ⋅⎝k  + 1⎠  \n",
       "───────────────────\n",
       "(a⋅k - b)⋅(a⋅k + b)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "p=symbols(\"p\",positive=true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA0AAAAQCAYAAADNo/U5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAABJUlEQVR4nJXSLUidcRTH8c+VKwoKDtcWxrIvCxPLkmWOsWCxLgkG8SWK6dzTzDMN1kS7BsGVhSlGQYOoRZx1C7OszGfhPtc9XO4desqPP5zv/3feakVReGzUq4/MfI1DbOAIC3iJPpxgNSK+9rR98qrUN9jET3zCN0xiLzOf17tAzzAVEQeVKj5iCcvdnBarQBmfSx25hzKzDyP4jq325vGj1N6q0zh6sR8Rdx2gF6VeV6FWaVcdAHhf6pdO0JP27MwcxjxusFOFJkqdzcyBCjCIbTzFSkT8rhVFITPruMU5hnCHXc2lzmiuYC0i1qHlNIp+zSuYxgXm8AFneNsC+HdGrX6OI+IS77oMQ9XpHvpfcifoD04fAtUajUYPfuEqIsYeAv0FPYpMz8iX324AAAAASUVORK5CYII=",
      "text/latex": [
       "$\\displaystyle p$"
      ],
      "text/plain": [
       "p"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "para=Parabola(Point(p/2,0),Line(x+p/2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFUAAAAXCAYAAAB6ZQM9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAEa0lEQVR4nO3ZaaydYxAH8N9VQiwhfJHaQ0KsiSVthAaNJcTOB40ljZ3S2lXomISotKgSgqIifBCVIEQtkaaLpbFWKYloEMRSGmLX68Pzntu3x7lLz729dZP+k5M5Z+Z55p33n3lm5n1PR2dnp3UYWKy/tgMYasjMiTgJu+IPvI6JEfFBY816aym2oYxDcA8OxGH4Gy9n5paNBR3rjn//kJmbYjlOiIhnqR3/zNwKJ+IY7IVt8CcW4WE8HBErBjvoIYDNlBO/rKGoH/9T8QBG4A1MwyzsiRl4IjM7BivSIYRpeFeprVi1UX2C4/BcPSMz8zq8iZOVAj1rEAIdEsjMKRiFgyPin4a+TzW1IvZm3B0Rl9T0B2I+7sJruAh7Y0O8j2si4tUmXy/icJwcEU/V9B1KmTkLt0bEte3dat+RmVdgKq6MiNta2HdV7uONiBjVZLsNp+PQiPiwbutr9/+rkn836fet5OF4VKkr92EuDsDzmbl9056rsAI3Zeawmn6qQugDg0FohXmVHNmN/S4Mw7i6MjOn64ZQ+jCnZub6OLP6+UKTuUHqcBwSEfNq+6bjElyKKxv6iHgvMx9VCDwDM6uTcDmewAW9xTSAeBu/KX1kFWTmqUqyTI+I92v6exRCT8CyzNy6Mv0SEb/Qt0ydrDSr5yNidpOtQeq4OqEVZlRy9xY+r8fvuDEzxymlZTbOGMwJIyL+wkJsl5nDG/rM3AS341tMatp2odLxX8HXtU9X4vSYqZl5Ka7AEiWr6rYNFcK+wGMttv9QyQ1a3MyXmTkN1ypHbAFOiog/e4qnuu5S7NDbuhoei4jTe7DPV5rNSDRq/CRsi7ERsbwp9l4noG5JzcyLcSc+xOiIWNa0ZC+FsNndZNeOlfy8m0t8V/t+dkT82luwFT5Vsryv+KoX+/xKjsBTmbkbLlMa7yOrcZ0utCQ1MyfgDnygEPpti2WNo7+0G9/HVPLFFv5PUxrTN9ga45Vj1SsiYnRf1q0GFqDTymZ1t9KcLo6Ith43/1NTM/MahdB3le7WilBWkrpFCx9b4jx8iaebbEcrGbBYGb+W4JwqQwYdEfEjPsL+mTkGo3FfRLzTrs9VSM3MG5TG9JaSod/3sHe/Sp5SFfaGj03xOLbC+Ij4vWY7CE8qZB8REd/hBuXETG73JgYA87CxMg5+rzTSttE1/GfmWZiJf5TmsbzF+qURMbMas37Gx9hcmTufUYb+45URa2JEdBGVmftgjjLCHBQRn9ZsC7E/RkXE3P7cUDvIzDOtrJ/nRsSMntb3hnpN3amSwzChm/VzFOL3wEZKMb8d03E2OpT3BmMjoquWZuYuysjUiSPrhFaYiJcwRfeD+JrEZ5VciAf766ytV3+ZORYP4fyIuL+/QaxtZOYzSmMdGREL++uv3ZfUjSbVdjH/v6BqTsfi3oEglPb/TtlXqb2LBiKIwUb1PmIMdlYewRfj6oHyv9qkZuZ62AdL6p19iOEo3IKflJFvwmo8fPSKdX+nrAH8CwS0g6EmdtU/AAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle 2 p x - y^{2}$"
      ],
      "text/plain": [
       "         2\n",
       "2⋅p⋅x - y "
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "para.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "F=para.focus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{p}{2}, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(p/2, 0)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "k=symbols(\"k\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(F,slope=k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\frac{k p}{2} - k x + y$"
      ],
      "text/plain": [
       "k⋅p          \n",
       "─── - k⋅x + y\n",
       " 2           "
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B=Intersection(para,l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{k p + 2 p \\left(\\frac{\\sqrt{k^{2} + 1}}{k} + \\frac{1}{k}\\right)}{2 k}, p \\left(\\frac{\\sqrt{k^{2} + 1}}{k} + \\frac{1}{k}\\right)\\right)$"
      ],
      "text/plain": [
       "Point2D((k*p + 2*p*(sqrt(k**2 + 1)/k + 1/k))/(2*k), p*(sqrt(k**2 + 1)/k + 1/k))"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm8AAAAfCAYAAACxiypgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAARnklEQVR4nO2defgdVXnHP2GXIIRNFksJIMpqYgR5EMEAVpBFCAVcCrJoaREKUdYg9s2XB5EGAjEFi4VAaMNWoTVRoYgKGvYtbNJIWcIu+xZoSQm//vGeSW4uM3dm7p353Xt/OZ/nyTP5zZx75j0z5z1zlvd9z7CBgQEikUgkEolEIv3BMt0WYGlA0i7dliESiUQikUh/IGkDSX+edT123mpG0v7AOgXSrS7pm4Mg0lKBpA91W4ZIpCiSViqYblNJu9UtTz8RdT3STxTVdeAZ4CRJa6VdHBaXTetD0tbAeDNr2SmTtCJwAXC0mb09KMINYcLznGxmR3fp/iOAzYDbunH/XsPMhnVbhl5H0vrAt8zstAJpTwWuNbN765est+kRXX+tG/fuRaKu51NS19cDpgJfMbP3G68tV5N8Sz2SlsE7ZF8pkPxs4OLYcauMHwFXdvH++wDvxIYsUhQze07Su5IONrN/zUl+FjBL0v5m9tZgyNfD9IKuH2hmP+2iDJE+ooyum9nzku4Cvg2c13gtLpvWx+HAQ2b2TKtEkrYFNjKz2YMj1tBG0t7ASmZ2UxfF2A34zy7eP9KfTAa+3crOBcDM3gUuAiYOhlC9StT1SB9TSNcD5wPfkbR248nYeasBScsCJ+Mzb3n8EDi3XomWDsISylR8NN4tGVYAVogzIpGymNl7wKX4THwe1wB7SNqkXql6k6jrkX6mjK6HFblrgO80no+dt3rYE1hgZnNaJZI0BtgE+O2gSDX0OQR4M++518wuwE1dvH+kv7kS2EvSlq0SBfuXGcAJgyJV7xF1PdLvFNL1wAx8pm54ciLavNXD14FrC6Q7HJhlZtFrpBqOAfLshepmb+AfqshI0gRgP+ATwLvA7cAEM3uoivwjvYeZvS7pOuBY4Iic5FcB90s63szm1y9dTxF1PdLXlNF1M3tA0hu4jeXlEGfeKkfScvjM2+9y0i0D7A/8ajDkGupIGgVsCdzZZVE2MLOnKsprLPBj4LP4KP894NeS1qgo/0hvciewf1iWy8TMHgVeAsYNilQ9QtT1yBCikK4HbgQOSP6IM2/VMwZYBbg/J91WePy3u2uXaOngS+F4X7cEkPSpKu9vZkvE85J0MPAGsAPw86ruE+k55gCrA9uTMwgEbgF2p/uzUINJ1PXIUKGMrt8DTJQ0zMwGYueterbDw0Tkjch2AF40sxcGQaalgR2AJ82smzGXvkxOQyvpu7in0dfN7IqS+X8Yny1/tT3xIn1CYsf1OfIb9IeAI+sVp+eIuh4ZKpTV9TXwpfW5g9Z5kzQSeAK41MwOHaz7doFNgecKpNsCeDovUYcNwNLE5sDzXZbh00Be4MUx4XhPG/lPwUf7t7fx244IO4V8HhgNjMI/LpeZ2UEV5D2k63jZ8pnZS5IW4nU6j/8GNpC0qpm92aGomfTYO4q6XiNR19unZl1P+gub0tx5k9RsOP8+Hj36AWCamV1W4Aa1ktcJlLQmbgOyJ7A18FFgAfAgcAlwSXOk4vC75rIvAN7EH9i9uKvur8xsYY6II4Eis2mbUKyT10kD0DXafQ9t3msZYEPgsSrya1OGjwLPFXA+GQO8hX90y+R/FrATsGOBOlgHp+IN+Xx825bNymYgaR28zp9vZsc0XOqZOt7Jh6vi8r2JtyV5JJ2YjUlZxmuUCRDt62RPvKOo64NC1PX833ZT10dCtsOCwr8zcVfonYAZks4pIVAzz+K9ywkd5FGEA4AL8eXLO/ARzDW4jdlFwL9JahX5Pin7JNyV93XgYNx79HZJH8+5/2rAOwXkXBtX7DzaagB6gE7fQxmG4/abtc08JISPRxp7k7+MMhyf8r63jIexpMnAN4Bdg5F6aSQdKmlA0th2fo/HGPo4sCrtL9Ptg7c5/9F0vpfq+KnA0XiD/mzJ31ZZvjfxtiSPZFlt7YzrjTJ1opO98o6irufnEXW9GH2l6yHe20CSNnXZ1MwmNv4taVfgBmC8pKlmNq+EYEme/wfMLfu7NngEt0f4ZeMoUtIpuGfHX+Iu2ddkyDmx+VzoZf8j3vj9WtI2ZvZixv2H44ameawM/G+rBA0NwOxuhRORdCg+Kt+5ZCTzjt5DSZKNfmsNlxAiup8tafOUGYpd8U5+K0bjCr/EqEzS6sB0/Hn9CDgh6AuSpuJbrO1sZg93WoZ2MbMbk/9LajebccArwO8b8qq8jndQZ8E/XM8Aj+Kj8htbJ1+CKss3Hyiy4fq74Tg843qjTMNoQyd7oR1qIOp6zfSLrneo59B/ug6u78OhoLepmf1G0lx85mxbYF6DwAfivddRwAr4g7gcOCds45KkG0nTcmfjOXyrlzOBL+Demg8BE83sFw15TAQs/HmIpEMaxDzMzKabWWrAWzP7k6QLgB/gbtmFOw1m9oKkr+Kj27HAKcD4jOQLgWULZLtsSNuK0RRsAPD3cgveybwN3wvtk8CK+LL3SY1KWTftvgdJn6V8ORaE48pVyd+MpG2CvJvi7vw3N1wbDiw0s5adcdxOBhrep6Tt8HhdawAHmNnVDdd+DBwE7Au8KmndcGl+v8X1krQaHgLh8qaloNGU/MjVSbsfrhrKtzLwPwVundzrA21Oikztto3tlqElUdejrof0UdeL6To09BvKxHlLptMX9SglnYFXxs3xDtt5Id0ZwPWSli+Y94b4yG8k7vJ+FT6VP1PSzg3pbmLxdij3s3iJUxRz204e2HsF5VpEGH2dHv78WovlhXdYPDpsxdsF0mU1AHOAnfEGYHyoCMla+1/gz/BV4CfAbLxjd62K7aM2GLR6D+2UYz5eL1etXlTHzO42s+Pwj8yXmy7vRrF4fUvYQwTj1tn4tPk2jY154EjcDuM3uL1D8u/4dsrQZfbEB3f/3nS+TB3vZaou36oUM6tIRuxvl5ApjVY6Wdc7irq+mKjrUddbEpbxlyfMOheaeZP0BXw6cAC4K5zbHrdfexr4jJn9KZyfgK8D74XPCJ1R4BZj8Vm2Rd1fSZfjG/6eQJjONLObJM3DIxLfl7bE2aIMy+G2BND+RsI3443bR/CO5hMpaV7CnRHyeA1X1lakNQBn4svPXzSzR1LSrg+MNbPG0eJU4O/wqORdbQwKvIfS5TCzhZKepcYGvYGfAd8CTmw4tyfFbDkTe4iXJc3EPwyXAkea2QdGXmZWlU1gLzAO72Dc0HS+TB3vZaou36o0rHC0IJmBSgubkSXTEpTQyarfUdT1QNT1qOsF7pv0F16GjM5bWJ4E7+V9Ap/KHQaca2ZPhmuHh+PpSccNfMNVSccBe+AVv0jn7UkWz2ol+Vwv6SngMwV+X4Qz8dm8a83s+nYyMLN3Jb2CB9ddm/TO2+N4zJY85gV5WlGmAUgqztGNjWDgIrwh3KKAXHWT9x7aLccfgcGYWZwJTJK0mZnNDaOhNVvYQAIgaSV8hvpFXLnXAY4wswurFjAMcDbMuHxjyhJBreF7Qtl3B65LWW4q9ZHrRaouX1iWWR6v03msF45LtEU5MjVTRCfreEdR1zsk6vrg0mVdXz8cH4fsmbfErmwA97acjYcKmdEkKKTYUZjZI5KeATaSNMLMXs8R6j5Ld4l+Go883BGSjgGOw3vAeYameXxg+biJh4F1JQ039w7JYi4+O5lKmQZA0oosjhuXFs7llXBsuYxdd0OQ9x46LMdtwM6tnntO+dL4gNt4qNt/xBVzLl4/7yiQ1yhc31bElXBGHY15YAowouncaNxD6lI+OMq7ryY5Er6I27Eu4ZlVxUeuRz5eVZdvVDjeUuDefwa8ntKhSJWpmQI6WUtHpE5dr0LPIep6m9Si6z2i59BdXd8gHP8Lsr1Ni0zhJq6tWcESn8dHR6vhHcBWZF1/jw73X5V0FG4n9zDuft12xOrwgpK95l7KSHYz3sHbgrDEnMGtwDqS1jKzl1Oul2kAtsYbuestPU7TyHDM2/VhCjU1BAXfQyfluIHF8YluzRDjMXI8fJvIisM3E38mk/CG/V8K5JXYQxyH72l7kKR7zGxKCXkKkZan3DNrH2C6teeZ1QnjcEPzXzadr+IjN4Xuf7yqLt8Y3Ha2eTYqja1Ir+9ZMi2ioE7W1RGpU9er0nOIul6WunR9Ct3Xc+iurn8SeNzMnofO9jZNwmGsS3rAxPWa0g06ksYD5+Keq7vmTXcX4HP4M3vBMsKlmNnjkh7HR2mtOm9348ar25HewJZpAJJZ0FSZcDsNyDG0rashKPEeOinHbNztexsyOm9mtmsBcYswEzhe0keALczsDwV+k5TtbuBqfCuUyZKeMrMiBuV9iaRl8bhYvzWz5rag449ctz9eNZXv08DPzKxIvMhP4fWxqExJmvEU08m6OiK16XqFeg5R1wtTp653W8/D/bqt62NoCGfSyazWnHAc23xB0sfw6fwnCiyZliXTNb5JhpPwxuk+PA5MRx23YO/wvfDn5TnJr8BjAWViZgvwqdesdI0NwFfxqdjJkvZrkXZE8wVJawBH4I3dzObrdVPyPbRdDvO4Ov+Ex+Krm9txo9HxeGicIozB3cHnhqWevfAloxnB+WeoshOwJunLd2XqeK9SafkkfQj/QJyfd2NJH8a9Mps9F1vJ1K5OVv2Ooq4PPaKu16frw/C+wlXJuU46bxeH46mSFkX3Dr3Ts0Pe0zrIP4vXcHuzTINVSd/HjXDvwUeVacuShQmjrivxjupT5DthXAzsIinPI2oasJ/Sw46UaQCSXv/+8jhEidyr4B3NNYFjCxguV0ob76HTcpwPbBYGD7URlnl+jnvBtYy0DiBpBXx568HEtjM4+eyBB12cVbfMnSJpX0nTJU0HTg6nt0/OSTo746f74dvspQ0chsJHruryjcOj8mct/TeyG3CnmTU7TmXK1IZOli5DqA8DYWYki6jrPUrU9Uy6qevb4eF8FvkYtL1sama3SpqEu1E/JOlq3H32S3jlvRk4q938W9x3vqQ7gB0lXYZH8l8IzDKzB+SBe08L52YDx6QYM84zs+lp+Wuxp+0y+KhwS3y5dAU8Ft1f5TV4Yen0F8CBuNdUVrrZcrf3z+Mx7BIZkgZgTmMDIGkP3LBxlqTtzexRuZv/Vnjcu9WAByTNwtfe98HX3ycM9nR92fdQRTnM7A15qJq/pf6QKLPwiPS/z0vIYvueOY0nzezhMDK7HrguvNOOBho1Mho4pOncxuEfuMd42jPfF7jVzJbY77dMHa+sBAWQtG+QGdwkBMKHK/z/ZTNrLOe+VFu+v8bDYxThUNLb2CyZyupku2VIJgVS42lGXY+6HnUdKKfrhwFTrMGxsxObN8zsJElz8B0WvoFX2sdwY9LJYWmwDg7Gp/13B76GOwg8g0fl3iikWZbsXRB+h0c8TiPxtF2Au/0+iRupXoNvTF90M/XvAz+VNM1ab5VxInASDZ03SjQA+ObSK+EeWOcAU4Fv4s/kDnzniSJBJaum7HvYkmrKMQ24WtLWZvZgW5IX4wZgkpnlBnw2s3tY7KXcfO1GfGBQK+GDPL2D30/Ed0EpjKRtcfOJc1Mu9+pHbjQFP1xVly/MVN1QpN5K2gRYi6bZoByZyupku+9oa7ztzHKWiLpeI1HXCzOa/tD1NfBVvyU6zMMGBlr1KyKdIOnv8ZFsSw8lSRcClxScPm3+7WH4Mu3fmNk/tydp96myHJJG4I3tEVXIFmkP+Q4sE4CNU5b2+p4qyxca6NOBo3IGe0n6acAFZnZX0/muPvOge6/gg/cTM9JEXR9idLve1U2Xdf104A9mdkXj+Y7CcERy+QGwR3hZrTgWOCpMv5YlMZSc0zJV71NZOcydZL6Xly5SO+OA+4diYx6osnzv4zZeRRrznXDbmjRv9m4/8x1x25xzWqSJuj706Ha9q5tu6fpmwFrNHTeIM2+1I3fm+K6ZtdxSRdJIYC8zO69k/rfgxoyrtDDu7XmGSjkikTqRtA5wuJn9sNuytEvU9Ugkn+C8cxpwSpqexJm3mjGzl4DJBdLNo6R3rjx8ySh8FN63jeBQKUckMgi81ecdt6jrkUgxlgNOztKT/wf4Ml8yd2RKIwAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{k p + 2 p \\left(- \\frac{\\sqrt{k^{2} + 1}}{k} + \\frac{1}{k}\\right)}{2 k}, p \\left(- \\frac{\\sqrt{k^{2} + 1}}{k} + \\frac{1}{k}\\right)\\right)$"
      ],
      "text/plain": [
       "Point2D((k*p + 2*p*(-sqrt(k**2 + 1)/k + 1/k))/(2*k), p*(-sqrt(k**2 + 1)/k + 1/k))"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\frac{\\left(k p + 2 p \\left(- \\frac{\\sqrt{k^{2} + 1}}{k} + \\frac{1}{k}\\right)\\right) \\left(k p + 2 p \\left(\\frac{\\sqrt{k^{2} + 1}}{k} + \\frac{1}{k}\\right)\\right)}{4 k^{2}}$"
      ],
      "text/plain": [
       "⎛          ⎛     ________    ⎞⎞ ⎛          ⎛   ________    ⎞⎞\n",
       "⎜          ⎜    ╱  2         ⎟⎟ ⎜          ⎜  ╱  2         ⎟⎟\n",
       "⎜          ⎜  ╲╱  k  + 1    1⎟⎟ ⎜          ⎜╲╱  k  + 1    1⎟⎟\n",
       "⎜k⋅p + 2⋅p⋅⎜- ─────────── + ─⎟⎟⋅⎜k⋅p + 2⋅p⋅⎜─────────── + ─⎟⎟\n",
       "⎝          ⎝       k        k⎠⎠ ⎝          ⎝     k        k⎠⎠\n",
       "─────────────────────────────────────────────────────────────\n",
       "                                2                            \n",
       "                             4⋅k                             "
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.x*B.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACsAAAAXCAYAAACS5bYWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAC8UlEQVR4nNWXW4iNURTHf2cczMOIeCAhT+RaRuNhHjSUQZPMcXmjlEsRk4cpjeJ/1tuUlEtEQ0LmkRByL/c3ZohcyjREHmZqNJNLzHjY++PzzXeOmfnOPPjXaZ2z11r//d/rrLW/c1I9PT38L0gnSTazOmAFMBX4BjwC6iQ9K4C2XihKmF8BHAbKgYXAD+CGmY1OyBuLVCHbwMxKgA6gWtLFghF7JGqDGIzAfVvtuQLMbCzwATgkqSbGvxY45T9ulHQs8CVtgyj2AU9wvZsLy/2+56IOM5sIHAQ64xILJtbM9gDzgdWSfuYJzQBtwJ1Ifgo44X1H4hLTkYRy4D7udA+BLcBsYDjQDOyQdDtG6F5gDbBA0ps8BxqJG8TGmAPVeF+Ft70QrWypt4uA07jeOwrcBcqAy2Y2KSLgQEjo81xCPaqAYcDZCMc0oB7YL+lOXCL0HrBA7HigQtK9iKhtuArU+rXDXmg10G5m43x4p6S4vssAXcD1EG8aV5hWYGeeg+as7NawUI9gKqeH1jbjboCbwMfQqza6kZkVA0uAK5K+hly7gTnAOklf8on9XVkzG+6FvAPOxMS2eTs0WJCUykceQSVQQugWMLN5uGrulfTwXwThys7yQq5K6o6Jnextaz8EhpEBvgOXvNDg638F7OoLQbhngxZoyRFb5e21/qo0syHAMuCWpA6/XAJM8e+/mllcaoOZNeAGb3uc2FExm40GNgHvgfP9FYu7f8fw94PgG3A8R3wpro/vAS9x1+hflZ3r7Sozy0rq8kJLgEa/2crIcPQVK4BuQgf1w7QhLtjMsl7syfDjNu2daWAm0ASMBJrN7ALuYbAcd5XVSTrLwFANPJD0aYD5wJ8BmwEU48pdiWv69cBa4AWwWFL9QDYwszJgAjG/BfqLoA2Cfn0s6TWwNClxCBlv+yxWUhbIRteDyv4Wm0RVDmSAJklvkxKFK/sTeJqUMApJ0wrFlcpms0XAZ6BF0sxCEQ8GCvq3ZrDxC6tL6XveYJfkAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle \\frac{p^{2}}{4}$"
      ],
      "text/plain": [
       " 2\n",
       "p \n",
       "──\n",
       "4 "
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACgAAAAXCAYAAAB50g0VAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAB70lEQVR4nM3WT4hOYRTH8c9Mo1GI2MgCO+XfgmymaBCShUmWY6UU+bOZ0qxOZ6ekRE0pO409ShFZIHaEyL+aECtTmAVlZize+07XbUa9XM37q9u5nec+5/l2znme53ZMTk5qZ3XNNkBmDmIfVuEHHmIwIp5B5yyyNdWLIfRgG37iVmYuho52K3FmzscX9EXEtXbIYFULNCo7SnuUuKqzeKzRi7O/ScrKzNPYgs0RMU7NgJnZg/s4jwc4gvXoxhOcjIg7M8w9g35sjYg3TX/dJd5Q2B24pNFHF3AXm3A9M5dPA3euBPe8PFZ3iZuAy9AbEfcqEMdwHAMl/1AB14fRzFxaDI1FxNj/yuDRMlyhi4VdXfEf1ti5t/Gp9AxQyWBmjmBFC0DDEdFfzO0uFn+P4Wm+/VzYOWVnRHT8aYFqid/iewuAH0vv64rFb0TExDTfrizsuxbi/w4YEdtbmVxRs7wjM4zvKezNVoLW2YNNwEXVgeJePYQPuNJK0DoBNxZ2f2bOazqLu/UyluBERLTSQvX8LGRmF77hJRZiAlc1Dui9GsfOYEScajV2XRlcg7kat8dOvMJBHMAL7PobOOo7qJv99ygiXmN3TXFry+AUYE3xplQn4Die1hRvSv+8STKzE18xEhFra6Eqqe1++av6BY8WkS0Wc4RCAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle - p^{2}$"
      ],
      "text/plain": [
       "  2\n",
       "-p "
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(A.y*B.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\sqrt{p^{2} \\left(\\frac{\\sqrt{k^{2} + 1}}{k} + \\frac{1}{k}\\right)^{2} + \\left(- \\frac{p}{2} + \\frac{k p + 2 p \\left(\\frac{\\sqrt{k^{2} + 1}}{k} + \\frac{1}{k}\\right)}{2 k}\\right)^{2}}$"
      ],
      "text/plain": [
       "         ______________________________________________________________\n",
       "        ╱                                                            2 \n",
       "       ╱                          ⎛                ⎛   ________    ⎞⎞  \n",
       "      ╱                       2   ⎜                ⎜  ╱  2         ⎟⎟  \n",
       "     ╱       ⎛   ________    ⎞    ⎜                ⎜╲╱  k  + 1    1⎟⎟  \n",
       "    ╱        ⎜  ╱  2         ⎟    ⎜      k⋅p + 2⋅p⋅⎜─────────── + ─⎟⎟  \n",
       "   ╱       2 ⎜╲╱  k  + 1    1⎟    ⎜  p             ⎝     k        k⎠⎟  \n",
       "  ╱       p ⋅⎜─────────── + ─⎟  + ⎜- ─ + ───────────────────────────⎟  \n",
       "╲╱           ⎝     k        k⎠    ⎝  2               2⋅k            ⎠  "
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.distance(F)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\frac{p \\left(k^{2} + \\sqrt{k^{2} + 1} + 1\\right)}{k^{2}}$"
      ],
      "text/plain": [
       "  ⎛        ________    ⎞\n",
       "  ⎜ 2     ╱  2         ⎟\n",
       "p⋅⎝k  + ╲╱  k  + 1  + 1⎠\n",
       "────────────────────────\n",
       "            2           \n",
       "           k            "
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "t=symbols(\"t\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIgAAAAyCAYAAACH65NBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAJJUlEQVR4nO2de9CUVR3HP6BcEhNRLO9KI10oBCfEEUGtzAsqmZeIysZScyZJZXKiEfO735w0Rw1Na7SbJlpmWb6kIpMSJWqGoqChg3kpxSwRwQsYIG9/nLPw8LzP7vvuPrvv7tp+ZnZgzznPeX4/nt/+zu+c8zsPfTo7O2nTphR981xse/daCdKmd7G9c0/abZ3jBiOBA4CfVHn9R4FJwAXVytBbSOrTaBnqwPa2T5J0VblGfaoZYmxvD1wOnCapqjHK9oXAPEl/rOb6NvmxPR1YJOkPpdpUO8R8B/hhtcYRGQ/cm+P6Nvm5HDjX9ralGlQ8xNh+P7CPpIerlcr2XsBySRuq7SPV32xgAnCPpBNr0WczUG+9JG2I9/gmcH5Wm2o8yNeBn+cRjBB7/D5nH0lmAl+sYX/NQm/oNQv4ku3BWZUVGYjtgcCJwB05hToSuCtnH5uIcczrteqvWegNvSS9BswHpmTVV+pBjgCWSVpdrUC2t4uCVd1Hm5rzADA5q6JSAzkUeCSnMDX1Hm1qwl+BcXGE2IJKDWQs8GROYY4FZufsoymwfb3tQqPlqAGPAlsB+6UrNs1ibA8FXiYEoScBHwZeAs5MzJOHAy9WK4XtrYDdJf2j2j7a1B5J62yvAvYhDDebSE5zi9bzVeAM4HngIuAm23sCbwM7Aa/kkGUCcF+O6zOxfTcwChhk+wXgJEkPdHNZ09PLeq0CdksXJg1kNLABOFLS36OAMwhDynCCwQC8lUOIScDNOa7PRNJhte6zGehlvVYBg9KFaQPpKBpHZF2JtpnY7gt8A7hR0gsZTcYQhrCWxPZ5wHmJogFAp+1zE2VHSWrFFeK1ZDzjtIH8MlU/BlgDPMXmgHb7rN5t70hYQDsaeAO4OlU/Angy5/J8o7kGuCXx/RJgOfD9RNnyXpWodgwE3kwXbg2bFsA+wJZBax/gLOAXkt6KZWspYSDx2uOBOwlDydWp+kmUmb3YbirDydrBlbQSWFn8bvt1YGXK625Bs+kFJXentyUjviwaxMj455QYGK0grM0PA05ItH8GGFLipv8GsH0j8CPbg1OLYZ8ArqhQ6B5j+6go647A1ZLuydNfrahFqkAv6bYb4fluQdFARhOGEROCyB2AucBYSf9JtH8UGNHNjW4nDEdHxb6wvRPwWtET1QNJc4A5MRXhEmDTP2LcrewADpPUaXtvYJSkjjg0zpI0sV6y5aXeutneAXg3sCRdV4wrRgOPSbpZ0u6StpH0aUnpNY97CUlC5ZRZQZhLfypRfAz59296ynTg2lTZqcAtifjnCKKhS3oFWG77wEpvJOkUSYUcslZKvXQbBTwt6V/piqQHmdMDATuAK2wP7MYbdADn2+4naT0hcD2zu85tfxmYBmwkJBNNizOEU2KTmZJ+Gn81vwaKKY/TJd2ZSEJalOr6c0SDtX0IcDHwiu3JwMFR3imkFolqRZZesbxZdBtPid31vjEYHUmGe0kj6SVgHmE/pRwdwGDg0BgADy7GKKWIKYzTgAmSRgEXxrTEKcD+wEHAdNvvI/xKXpU0EtgXWBAfwrHACba/kui3P7BzlB1Jf4q6Hi5pdNzNXASM607/asjSK5Y3k24TgZuyKraOrmm7CnS+lJBgclupBpKesv0EwbL7E4yqOz4G/ErSqtjHStsnA7dKWgustX0HcCCwEJhp+7vAbEn3Az+LnzRDCYtASfYGnkt8fxnYpQcyVkMXvWL5eJpAN9vDgQ2SHsqqrzhhSNJ8YH209nJ0EKa2Zae33ZA1A+iUtIywNbCUMORNLdPHWsKCFrApE/+l1HrMAPKtEFdDs+g2FSiUqqw2J/Wscp1GOoA9gIMk/a0Hfc4DJhczm2Jk/WfgeNsDYx7JROAvtncF3pR0A3AlIYbKRNKrQH/bxXhrD7puOO5DeCD1IEsvaALd4h7boHLT5qoMRNKzwGzbnynT7EHCbnDJjOlUn48T1knus70YmBEDspuBh4D7gUslPUOImRbafpTwC/heN93PZ/Psaymwl+3HYnwAcAg9C9IrJkuvWN5Q3eK2yDmE+Kg0nZ2dVX8KhcLEbuqvKRQKh+a5Ry0+hUJhbKFQuLZM/bxCoTCk0XL2pm6FQuGAQqGwc3f9V3UuphWJM4Hr0ntBcTFpgqTbGiJYDainbv83BtKmOnKdzW3zzqdtIG3KUtzub48zbbogqU87BmlTlqpf//BOw/YehGOI7wHWA5b028ZK1XjaMchmNgBnSxoBfBK40vY2DZap4bSHmBLYXgIcI+mfGXVDCNn+4yQ9XeL63wD3S+puJbSpaTkPYnu+7XS+a63vMQbox+ajHmnOA+5KGofty+KObJFvE3JiMk/NtwotZyD1Jq4+3gCcmpWBH4ed0+n66q39CfsqAEhaAjwLfKF+0taflgpSbV9P2Hw6xHYxQ20Y8EHCJthHYtlC4BxJSxPXzidsZq0mPOCNhGMa0yVtjG0GAL8DLo55GFkcHa9dEK/pRzgu0A842PYFwOMx4Wc2IePrB3l1bxSt5kHOJqTOXUdIgtmFMAwMIuyYjiUY0Grg9vjAk3ye8HDHEVIWphFfexAz664npPXNKiPDeODhhHd5O5ZB2FXdhZDqB2FHe3/b76pc1eagpTyIpNW21wFriml2kVuT7WyfArxGcPsLElVPSJoR/77M9mnAxwkHxg4iGMsS28fFNidLeiwlxt4kci4kbYw5HK8DC1PD0osEz7IrkBnMNjstZSClsD2MkOt5IOGAed/42TPVdHHq+3LgvQCSFtAzjzqQrhla+wGLM2KWtfHPtgdpMLcTfq1nEB76BkK80T/Vbn3qeyeVD7Mr6Hp4bDTZL9YpZo+9XOE9moZWi0EgHCjfqvglzjpGABdJulvSE4RDQPUy/kfoenis1KmAkcCL3WX0NzOt6EGeA8bGE2RvEM7KrgBOt/084QjhpQQvUg/mApfYHhoPiUH4oe0bY5E1xQx2QrDa0q/bakUPchnBiywluO49CcHlvsDjhCnlt4D/1uPmMWh9EPhsongG4eD6C4SXDBNnLscBP66HHL1Fe6m9CmwfAVwFfEjS2yXaTAUmSTq8V4WrMa3oQRqOpLmE11uU+98u1gFf6x2J6kfbg7QpS9uDtCnL/wDq6FvhR+NaggAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle \\frac{p \\left(\\sqrt{\\frac{1}{\\cos^{2}{\\left(t \\right)}}} + \\frac{1}{\\cos^{2}{\\left(t \\right)}}\\right)}{\\tan^{2}{\\left(t \\right)}}$"
      ],
      "text/plain": [
       "  ⎛     _________          ⎞\n",
       "  ⎜    ╱    1          1   ⎟\n",
       "p⋅⎜   ╱  ───────  + ───────⎟\n",
       "  ⎜  ╱      2          2   ⎟\n",
       "  ⎝╲╱    cos (t)    cos (t)⎠\n",
       "────────────────────────────\n",
       "             2              \n",
       "          tan (t)           "
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trigsimp(_.subs(k,tan(t)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\frac{p \\left(\\sqrt{\\frac{1}{\\cos^{2}{\\left(t \\right)}}} + \\frac{1}{\\cos^{2}{\\left(t \\right)}}\\right) \\cos^{2}{\\left(t \\right)}}{\\cos^{2}{\\left(t - \\frac{\\pi}{2} \\right)}}$"
      ],
      "text/plain": [
       "  ⎛     _________          ⎞        \n",
       "  ⎜    ╱    1          1   ⎟    2   \n",
       "p⋅⎜   ╱  ───────  + ───────⎟⋅cos (t)\n",
       "  ⎜  ╱      2          2   ⎟        \n",
       "  ⎝╲╱    cos (t)    cos (t)⎠        \n",
       "────────────────────────────────────\n",
       "               2⎛    π⎞             \n",
       "            cos ⎜t - ─⎟             \n",
       "                ⎝    2⎠             "
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.rewrite(cos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\frac{p \\left(\\sqrt{\\frac{1}{\\cos^{2}{\\left(t \\right)}}} \\cos^{2}{\\left(t \\right)} + 1\\right)}{\\sin^{2}{\\left(t \\right)}}$"
      ],
      "text/plain": [
       "  ⎛     _________            ⎞\n",
       "  ⎜    ╱    1        2       ⎟\n",
       "p⋅⎜   ╱  ─────── ⋅cos (t) + 1⎟\n",
       "  ⎜  ╱      2                ⎟\n",
       "  ⎝╲╱    cos (t)             ⎠\n",
       "──────────────────────────────\n",
       "              2               \n",
       "           sin (t)            "
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\frac{1}{\\sqrt{p^{2} \\left(\\frac{\\sqrt{k^{2} + 1}}{k} + \\frac{1}{k}\\right)^{2} + \\left(- \\frac{p}{2} + \\frac{k p + 2 p \\left(\\frac{\\sqrt{k^{2} + 1}}{k} + \\frac{1}{k}\\right)}{2 k}\\right)^{2}}} + \\frac{1}{\\sqrt{p^{2} \\left(- \\frac{\\sqrt{k^{2} + 1}}{k} + \\frac{1}{k}\\right)^{2} + \\left(- \\frac{p}{2} + \\frac{k p + 2 p \\left(- \\frac{\\sqrt{k^{2} + 1}}{k} + \\frac{1}{k}\\right)}{2 k}\\right)^{2}}}$"
      ],
      "text/plain": [
       "                                   1                                          \n",
       "─────────────────────────────────────────────────────────────────────── + ────\n",
       "         ______________________________________________________________       \n",
       "        ╱                                                            2        \n",
       "       ╱                          ⎛                ⎛   ________    ⎞⎞         \n",
       "      ╱                       2   ⎜                ⎜  ╱  2         ⎟⎟         \n",
       "     ╱       ⎛   ________    ⎞    ⎜                ⎜╲╱  k  + 1    1⎟⎟         \n",
       "    ╱        ⎜  ╱  2         ⎟    ⎜      k⋅p + 2⋅p⋅⎜─────────── + ─⎟⎟         \n",
       "   ╱       2 ⎜╲╱  k  + 1    1⎟    ⎜  p             ⎝     k        k⎠⎟        ╱\n",
       "  ╱       p ⋅⎜─────────── + ─⎟  + ⎜- ─ + ───────────────────────────⎟       ╱ \n",
       "╲╱           ⎝     k        k⎠    ⎝  2               2⋅k            ⎠     ╲╱  \n",
       "\n",
       "                                 1                                     \n",
       "───────────────────────────────────────────────────────────────────────\n",
       "     __________________________________________________________________\n",
       "    ╱                                                                2 \n",
       "   ╱                            ⎛                ⎛     ________    ⎞⎞  \n",
       "  ╱                         2   ⎜                ⎜    ╱  2         ⎟⎟  \n",
       " ╱       ⎛     ________    ⎞    ⎜                ⎜  ╲╱  k  + 1    1⎟⎟  \n",
       "╱        ⎜    ╱  2         ⎟    ⎜      k⋅p + 2⋅p⋅⎜- ─────────── + ─⎟⎟  \n",
       "       2 ⎜  ╲╱  k  + 1    1⎟    ⎜  p             ⎝       k        k⎠⎟  \n",
       "      p ⋅⎜- ─────────── + ─⎟  + ⎜- ─ + ─────────────────────────────⎟  \n",
       "         ⎝       k        k⎠    ⎝  2                2⋅k             ⎠  "
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1/A.distance(F)+1/B.distance(F)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\frac{k^{2} \\sqrt{k^{2} + 1} \\left(\\sqrt{k^{2} + 1} + \\left|{\\sqrt{k^{2} + 1} - 1}\\right| + 1\\right)}{p \\left(\\sqrt{k^{2} + 1} + 1\\right) \\sqrt{k^{4} + 2 k^{2} + 1} \\left|{\\sqrt{k^{2} + 1} - 1}\\right|}$"
      ],
      "text/plain": [
       "        ________ ⎛   ________   │   ________    │    ⎞  \n",
       "   2   ╱  2      ⎜  ╱  2        │  ╱  2         │    ⎟  \n",
       "  k ⋅╲╱  k  + 1 ⋅⎝╲╱  k  + 1  + │╲╱  k  + 1  - 1│ + 1⎠  \n",
       "────────────────────────────────────────────────────────\n",
       "  ⎛   ________    ⎞    _______________ │   ________    │\n",
       "  ⎜  ╱  2         ⎟   ╱  4      2      │  ╱  2         │\n",
       "p⋅⎝╲╱  k  + 1  + 1⎠⋅╲╱  k  + 2⋅k  + 1 ⋅│╲╱  k  + 1  - 1│"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEkAAAAcCAYAAAAtMJKYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAADIklEQVR4nO3ZTYiVdRTH8Y82FKSrdlE0QlGtMihKhCYyAu1l0WIgJKIWtbAWSSoi0elEQ4S1qOxNCBISIgYhqJRoUaRGTDRmCC0aKkEXJUMRVLTotnieicfbM3PvHe/LA/WFy7333PM853D4P+d//r+7otVq+Z+lGRt1AqMmMyewHdfhYkxGxHTVZ+UoEhs0mflmZj7ZpfsqfIVHFnNo7ErKzEm8hSsj4ofS9gJux/qI+KkfcSLiIA6W96/1afJKmsbXeBwycxvuwcZ+FahbGlukiGhhF+7PzJ14AndExNywc1nR9N0tM4/iBtwZEYcW8dmlKOgCF6CFPyu2TRHxaYdYLTWNu7E9CTJzA9YqVvyPS7i+hncq35/FKbxYsZ1abh7/FCkzH8Nz2BYRz9ckfBWO4/OImFhuwG7JzLU4gC24G1PYVOcbEfOYr1z7K+Yj4tt+5FJdSYfL93WL+L6E8yyxVfaLzBzHB9gdEfsycxbHMvOmTo/MMmKtxhUV05rMvFZR5JOc3bi/xO+4seZGk7gNL0fE8X4mWRPrIhzCexExBWXMaTwzgJDXY7Z8we7y81MLDmc17sz8BBO4JCJOl7ZV+AbnK2aWXwaQaKNpb9xHFEVap+gHFFvvpXigU4Ey83uM9xB/f0Tc24P/SKgrEsUjdyAzr8ZWfIZ9XdxvDn/0EP90D74jo71IRxXzxULz3qNo1g+Xw92SRMSt/UiqnFcaw7+Gycw8gTV4EPvxakRsGX5qzaHuWHIYF+J1nFGenf7L1E3cR/AQVmNrOagNnW50nmFRt5K+K99n8MYQc2mno84zLOpW0nb8pctmPSi60Xn6QTe61cq2CzbjLkWznhlYZs2io241lpmXYTMux304gR0jSXcERESrlFrez8w5heSyoapbjWGj4kz0M97FoxHx2wjyPSdKTTs6uN0SER+3GyPiw8ycwdMK3eqL6u9jEbEXe/uU6yjZg7c7+JysM3bSrRotuvVCRJxRzHU90Y1u1Vj5tk3nmVXsuh+p6Dx9iDGuOIq9EhFTmXkNjuHmqm7V2D8CdKHznAu96FaNXUlN4m/VJDhwJVCaswAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle y - \\frac{x + 1}{1 - x}$"
      ],
      "text/plain": [
       "    x + 1\n",
       "y - ─────\n",
       "    1 - x"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y-(1+x)/(1-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAD8AAAAjCAYAAAAjS9I/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAD5klEQVR4nOWZT2gdVRTGf0lsaquiWETrykUJYkWrqQtdBNwogoJQFfEPCopQqhSLBW2Ez9ONqDSFolgRNOKi4h8q+KeLKooK6qKkRaNYtaC1CNrGihRN0yQu7h2YTObMffPy8prXfhAOuee7M+fMvXPPme91TU9Pc7rijCqnmZ0NDAJTkgbbE9KM+w8AG4F+YDlwu6S3E3N2AJ8BL0maquJ2V1xkKfAJ8MPJSDziLGAf8HCNOQ8ClwI7zKyrili18k8Co5KGiw4z+w0YkjSUG1sFfA1cJem7GsG6kLQL2BWv3+icY8B6M/sAuA8Y9rilK29mPcBDwHZn3pfANYWxrcDLrUq8BXidxI7xtv0VwDLgR8c/I3kzWwNcCah+jPOGg0C/mZ3rEbxt3xdtj+P/CthiZucDx4Bngc2SjhSJZvYU6YdyvaRPE5y6yHJbAeypIhSRPa0zHf8e4DiwGrgamABecLjPA28kAv014W8GvdHWXvls4uIyp6RxMxsBbiEcKndJmnC4h4HDDYXbWiyKttcjVNZ5/G0P4b1fD+yW9H7NwBpC7DNW5IYuiVVlTFJqt7hlPEMq+ar2by8wBWxI3WQOWE3oNTI8F+1rwP2JucnWNZX80QrfPYQuajR1k2YRD8HKRqUCf6cIXvJLgHHgj/ygmXUDFwAPAJcDdzQZWDtwMNrzPIL3XqwC3pNU3DoDwO/AvcAaSX/NMcB5g6RfCK3xSo/TVfyqM7OLgFHgBkml9bFTYGa3AkPASkn/Fv3dBfKFwKvA2k5PHEDSu4Q+45WyTq+47d8hlK432xBbu7AVOBLtDJRt+23ApKRHy65kZgtO/ZBUWhHiAb0T+FjStqK/LPlFwAFgg6S35iHWtsHMBoEbJQ2U+WeVOkkTZraT0L2d1OSbUXJyc3uAdYQDrxReqTsAXBd3QUthZsPxS68RNKPkZOgjPLCfPILX5JwgdFbLKfniWshKTg4XR/ufR0g1/0ud8U5QcpakCKnkvZO9E5ScJLxtnyV9wvHXUXI2AZtyQ4uBaTN7LDd2k6TPa0WexmS0bmn2kh+P1ntf6ig524F80/QMcAjI191DXoBzQCauzGprM3jJZ8rLeJmzppIzBoxl/5vZPwQxwj2FW4Rs4f70CF7y30bbyUpOL2HxfvYIpQdeXJX9hF8+POylPUrOSPyDoOSMAJsbmNsPfCTpuEeY1d5mMLO7CWrNzZImS/y7gf2S1jUQSFthZucA3wN3SvrC47nJx4s8TfgB43FJ3xSUnEeAyxaaoGFmfcCLwIeStlRxK+u8pCcItfvaONQJSs5twMZU4pBY+VMdSW37VMZpnfz/hER2DVHTK4oAAAAASUVORK5CYII=",
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{y - 1}{y + 1}\\right\\}$"
      ],
      "text/plain": [
       "⎧y - 1⎫\n",
       "⎨─────⎬\n",
       "⎩y + 1⎭"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=Point(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(x, y\\right)$"
      ],
      "text/plain": [
       "Point2D(x, y)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "r=symbols(\"r\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=Circle((0,0),r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/latex": [
       "$\\displaystyle \\operatorname{Circle}\\left(\\operatorname{Point2D}\\left(0, 0\\right), r\\right)$"
      ],
      "text/plain": [
       "Circle(Point2D(0, 0), r)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1,l2=c.tangent_lines(P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAAwCAYAAABAM0OWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAATnElEQVR4nO2dfawdVbnGfwfaSxSktgglFrB+XG8uAj3VGiMflw8xUOSjAgXFqDFoFIkaTNW0yH36ioBiqEHBW2NiEEzEXESoBUEjViAWQcKhl2hEixXhKqXSUopoWzj3j7VO75zZM3vW7D2zZ8/p+iUnp539rlnPemfNc2bPrLVmZHx8nDRmdiKwSdJYx4cZmNkcYF9Jvw2Jj0TyMLO3S1rbtI7dATM7C1gj6W8FcdEPIo0Q/WCwhHrCBCPpCwgzey1wpqSrAit8OfBJSV8qK3ZYMbPOq6rIIDlH0n83LWKqY2bTgC8Dn5H0Uk5M9AOzzwFTpj0tJPrBgAjxhCTTMrYJ+ESJOpcC/1Uivg2slHRB0yJ2V8zsEjObI+nJprVMZSTtNLMfA+cB380LI/rBXEkjTYvYXYl+MDgCPWEXeyT/Y2ZHANskPRdSmZm9Gpgt6X97ETuMmNnhwP80rWM359vAxU2L2E34GfABM/uX9AfRD6IfDAnRDwZLriekSd+B+DBwe4mKPgr8sER8GzgNuL5pEbszkp40s9lmdoikx5vWU4SZHQzcABwA7ABM0s1t0CBp3MzuBc4Ebkx9HP0g+kHjtM0PYEp7wiTSFxBnAP9ZQuNiYEWJ+DYwR9ITVe6wzZ2pQQ13A+/FPY9rBDPbW9LzAaE7gU9JetjMDgAeNLM7JP29ZonBGgrasha4gE6ziH5Qgx9A8+dj0/X3oKFNfgBD7gkBbcnzhEnseoRhZnNxtyu3hCjztyt3SHo2JL4NmNls4K817HriQB4KvBO42g82GyRt0/Ar4MSBKUthZicAs0NiJf1F0sP+3xuBzcCrapTXi4bFZrZHZmG4HzjGzHY9549+UKsfQPPnY9P1l9XQGj+AVnhCNz+ADE/IIrmDNwFlnl3OB9aXiG8DpwGrq95pCzrTMGp4BHjzoLQlMbMZwAJJj/VQdgEwHfhz5cL607AG+FBWvP+jPwIcmNgc/aAmP4Dmz8em6+9BQyv9wJcfRk9YQ44fQK4ndJC8gDgY2FJC09yS8W1gVNJDdVYwpJ1p6DRI2ga8wsz2HagwxxLglrKFzGw/3PPy8yU1MhU4T4OkDbhvFHkDozbjPGCC6AcD8ANo/nxsuv4QDW30AxheTwjwA+j0hA6SFxB7+wIhgqYDM0rGDzVm9jKgludTE+3vpTOZ2XVmtrxCLaU0VF1/SQ1bgCYM41hJj5YpYGZ74QYQXiHplyXKVZbfAA2/A47PKb4Z2Cfx/6H1gzr6ZEYdtfuB/3ej52PLPGkLLfED6M0TashtNw3d/AA6PaGD5CDKcWDPDAEH4a4K3wd8DHgb8BHc7Y0XQ+PN7HJghaQVidhR3LOt+ZJ+001oCGa2GDd39Y2S/uS3XQ2cAhwp6Wm/7QzgPklPJYq/Azd9pV8Nee3/Pj38gSlRb2Hbe/0jV0LDExQc45IaXiQ11bhujbjBXFszynXNL/A14C5JN1Spt4Tu3wLXFWgYAxYCd2Z8Ng1ILhzTej/w+ww5LwbuB8D1dZ6P0Q+q0UjvfrCJ4vOxbu1FnjBGvh9Apyd0kDwYzwKvzIgZ9b+XAJcDh+KeCz5fMn4t8NZU7FeBb1VlFsBNuDnbnwcwsyXAe4CTExcPi4CVwKJU2eOAn1egYdT/Trb/NmruTBS03Q+GqVtD12Pcg4aZQNAaBCUo6oevAzZmlMvNL/BvwLnAIjMb8z+HD1j3UQEaNuLal8VMJhvlVPADKD4vFjF4P1g9gPMx+kEYlfuB/1sTcj7Wrb1IQzc/gE5P6CB5B2KDL5BmHvACcHZyEImZPe4FhsavBT6e+P9ZPvbsbgLLIDd/dRlwm5mtB5YBJ0han4i5xT9HOxf4ptcyAkyXtL0CGR3tN7OjfX3rvGEBvF9SZQvUBLR9ojPVpgHXobsd42AN/hbyDklBt8Ur1Lg/GSdNQX7XU/E3o7K6Jd0boGErbspcFjNxHjDBBlruB1B8XjThB76OWj0h+kFlGnvxg9DzsVbtARq6+QF0ekIHyQuIh4F/z4gZBVZnjEBdh1vmNjT+PuAqM5uF+7ZyJfAFZby0wz8Dytp3kuMlrUlvlPQTM3sA+CJwqqRfZ5T9EXCtme3jB+csAB7IqqQHLaOk2l+mM/lOuSyxaS9g3F/hTrBQ0j3pst3aHqqhn/opOMYlT6qDcSOvszQup8f+UaQR+AduMFcHgX2rK33kN/j86cJ03B+ztKZZwFZJzyQ2D5Mf9NMnQ45bsB94PcsJ73+jZLR/EOdjFX7Qp4aB+IHXuJzePKGtfhCivYhMP/C6sjyhg10HT9Im4Gkze00qZh5uysckJP0BmGFme4fEAw8C23En50W4Z0vX5ui6Bmde3X7uzypobr7uPN+2rFtP+KvYB4CT/KZTyF9xr6yWvPaHshJnOhM/qzK2ZXbUkLbXWT/ljnERRwO/yPms5/4RoPEp3IDADhrObxW53RfXvjRHksr1kPlBP32y8LiV9AMo1//a7gf9aBiUH0DvntBWPwjRXkSeH0CGJ2SRXonye8Cx+KVbvRm8HsibynQT7sDeWRQv6Z9m9hBubvUHgfMk7cjaqTevTUXi05jZPOBm3G2ddwOX4QaJZLEKOB34ATAr70qrjJaAfBXidezSYmbPAc94g+5Wd5m2V16/Lxt8jAM4ipyXMvXaPwI1rgMOSZdrOr8V5fYNZJvo0UDW2w6HxQ967pMljluQH3g9Qf1vKvhBPxoG5Qe+rp48oa1+EKi9iDw/gHxPmET69tE3cMmY4Aj/e11O+RW4gSOh8WuBC4G1kipdoMV/U7od+Iqk7+CW4D3JzI7JKXIr8C5zryveUJGMovbXQg9tr5O+j7G5aW4H9nJLMJBcjXILqGy1yVPthiW//eb2LWQvjDSf7G/crfUDKH3coh/UQ/SDeuknv3l+APmeMIlJFxA+WfeY2WF+0zzg98pZM1vurXuPm1vGtjAeN23kJeDTRcLK4J/X3IF71niZ17YO943oiqwykv6IW2nvy7hnoFVQ1P7K6aXtNTNG/8f4XODrlajJZozuGlfibmMPW37H6DG35pat3Uup+exmdjJwo6Sd6TJt9QMof9yiH9TGGNEP6mSMHvKb5wf+s1xPSDMyPj553Q5zK1MtBy5W2MIm+wAXSbo0IPanwKOSLiyKHQRmdilwltxa7JEK6PcY+9HWn5Vk1SqbVEehRjNbKqkJQ8iln9ya2enAY5IeSWzbE3frdWneuR79INIP0Q/qpdf8ZvmB317oCUnSYyCQtN3MVhA4D1rSNnOrZ82TX9c8JWgP3FSY84HDgHOK9jlAVpEzwjYSTsXHeCFuNHGl9KBxpZkdrmqntZWmwtxuSZsF7m2bV3YziugHkbJEP6iXivKb5QcQ4AlJOu5AVI2ZHQfchVs283zVsOJZP5jZSGiyItkM+zGGdmjMoq268xj29kQ/6J9hP8bQDo15DJP22i8gIpFIJBKJTD3qXikrEolEIpHIFCReQEQikUgkEinNNAAzi88xIpFIJBKJZCJpJL0tjoGIRCKRSCRSmtxHGH4+dyQSmaL4OfahsdEPIpEpThlPgJwLCDM7EbdOdmilc8ws6819kUgpzOztTWvYjTjFzPYrCop+EGmK6AcDJ8gTJshaifK1wJmSrgrZgZm9HPikpC+VkjnExDEhjXOOpMIXuUT6w8ym4ZZu/oykl3Jioh+YfQ6YMu1pIdEPBkSIJyTpWIkS9071T5Socyld3pLWUlZKuqBpEbsrZnaJmc2R9GTTWqYyknaa2Y+B84Dv5oUR/WBu1gCyyGCIfjA4Aj1hF5MeYZjZEcA2Sc+FVOZfmjPbv0RnSmBmhwONL1e6m/Nt4OKmRewm/Az4gH/nxSSiH0Q/GBKiHwyWXE9Ikx4D8WECXuGZ4KPAD0vEt4HTcGviRxrCf9OYbWaHNK1lquOXbb4XODPj4+gH0Q8aJ/rBYCnwhEmkH2GcgXu3eSiLgRUl4tvAHElPVLlDMzsYuAE4ANgBmKSbq6xjCmq4G3gv7nncUNPC3KZZC1wA3JjaHv2gBj+A5vtM0/X3oKE1fgCtzG+aPE+YxK47EGY2F3e7ckuguFcDOyQ9Gyho6DGz2cBfa9j1TuBT/jXB7wSu9oPNBknbNPwKOHFgyjIws70DQ4c+twVtuR84xsxGEvFziX5Qlx9A832m6frLamiTH8CQ5zegLR2ekEXyEcabgDLPLucD60vEt4HTgNVV71TSXyZebSxpI7AZeFXV9UwxDY8Abx6UtjRmdgIwOyS2Jbld7F8DnFX2WWAEODCxOfpBTX4AzfeZpuvvQUNr/ABakd9cP/DxWZ7QQXIHBwNbSuibWzK+DYxKeqjOCsxsATAd+HOd9bRdg6RtwCvMbN+BCgPMbAawQNJjPZQd1tyuAT7UpdhmnAdMEP1gAH4AzfeZpusP0dBWP/DlhzG/a+juB9DpCR0kLyD29gVCxEwHZpSMH2r8Clx/r2nf0/3v/YDrce9wD1prwsyuM7PlFWoppaHq+ktq2AIM3DCAJcAtZQsN8/GVtAF3SzJvZPVmILna5ND6QR19MqOO2v3A/7vR83GY+2wGW2iRH0DzxzdPQ4AfQKcndJAcRDkO7JlR+UG4q5b3AR8D3gZ8BHd748XQeDN7ATev9I2S/uRjrwZOAY6U9HQ3oSGY2RPACkkrEttGcc/P5kv6jd92BnCfpKcSxd+Bm77Sr4a89n8fN0L9Ckm/7LeejHoXU5BfM9urZg2F+S+p4UUqfmNsSJ6AYyVdUqYcsJXhz+3vgOOBOzM+mwYkF45pvR/4fYbkbeB+AFxf5/kY/SBYYy1+0JL8dvMD6PSEDpIH41nglRkxo/73EuBy4FDcc8HnS8bfhJtP/XkAM1sCvAc4uSqzwI0cfWtq21eBbyUuHhYBK4FFqbjjgJ9XoGHU/062/zbgOuAuSTdUUEcWXfPrB8PUraFr/nvQMBMIWoOgBEV5+lfcxUBwOWAT7cjtGLAw57OZTG73VPADKM7bIgbvB6sHcD5GPwijcj9oUX7HyPcD6PSEDpJ3IDb4AmnmAS8AZyefAZnZ48BRofG+zDLgNjNbDywDTpBU5cCrtcDHE/Wd5fWcPbFN0i3+Odq5wDd93AgwXdL2CjR0tN/Mjvb1rfOGBfB+SZUtUCNpvCC/R9WtgeL8B2vwt5B3SAq6LR5KQJ5eB2wsU24Qx5dqcrsR174sZuI8YIINtN8PoCBvTfiBr6PWPhP9IIw6/KBs2/qg3/x28wPo9IQOkhcQDwNZL8AZBVZnDCBZh1vmNjQeST8xsweALwKnSvp1lij/DChr30mOl7Qmte0+4Cozm4X7RnQl8AVJf0vF/Qi41sz28YNzFgAPVKRllFT7Jd1L4K033ymXJTbtBYz7K9wJFkq6J122W35DNfRTPwX5L5MH3OCdR3I0Lqe3/oHX0a0f7k/OVXdeuQEd3ypyuxU3JzytaRawVdIzic3D5Ae19UlPsB94PcsJ73+jZLR/EOdjFX7Qp4aB+IHXuJwePaFqP/CftcFvM/3A68ryhA527VzSJuBpM3tNKmYebsTmJCT9AZhhnfNJM+O9qBP853uQcVWX4BqceXX7uT+j3IPAdpwBXIRbPOPaDO2bcQZxkt90Cvkr7pXVktv+QFbiTGfiZ1XGtjyjDc1vLfUTmP9AjgZ+kfNZr/0DKMzTP3CjlcuWC6XX/FaR2+m4b8NpjiSV6yHzg1r7ZEk/gHL9r+1+0I+GQfkB9OEJLfUD6D+/eX4AGZ6QRXolyu8Bx+JGbOLN4PVA3lSmm3AH9s6ieDObB9yMu+XybuAycp6/ePPaVCQ+o9w/zewh3PztDwLnSdqRE74KOB34ATAr70qrjJaAfBXidezSYmbPAc94g+5Wd3B+66jfly2T/yKOIuelTL32DwjK01O4GQVlywXRa34ryu2+uPalORrIetvhsPjBIPpkkB/4fQb1v6ngB/1oGJQf+Lp68oS2+oEv229+8/wA8j1hEunbG9/AJWOCI/zvdTnlV+AGjnSN999ibge+Iuk7uOVxTzKzY4oE9sBa4EJgraRui8DcCrzL3OuKN1RUd1G+amHA+S0iNP+5mJvmdmDeLe1eCczTOuCQHsoNgn5z+wayv4XNJ/sb91TwAwjLW/SDeoh+UC/95DfPDyDfEyYx6QJCbvWpe8zsML9pHvB7Sc9nFZZ7697j5paxzYz3z1LuwD0HvMyXW4f7tnJFkcAeGMNNPfl0tyBJf8SttPdl3DPQKuiarzpoIL9FjBGQ/wLOBb5eiRpPaJ78ObDV/n/tjmHK7xj95fYtpFZWNLOTgRsl7UwHTxE/gIC8RT+ojTGiH9TJGL3nt8MPoLsnpBkZH5+8toW5hSWWAxcrbOGLfYCLJF0aKLpWzOynwKOSLgyIvRQ4S26t8EgFlMl/TvmXAZ+VZNUqK6XhVGBPSbc2pSGLfnJrbtnaayQlR23vibv1ujTvXG+7H0B43qIfVE/0g3rpNb9ZfuC3F3pCkvQYCCRtN7MVBM6DlrTN3OpZ8+TX3R40Phn7A+cDhwHnBBZdRc4AmUg4feQ/i4W40cSNIWm1mS3F3dZulApzeyrukUSSM4AruxlFG/0Aes5b9IMKiH5QLxXlN8sPIMATknTcgWgjZnYccBduZa3zVWLVLzMbCU1WJJt+8j+smNlM4CBVO2+7Fx3HUUFuzew/JN1dobShpte8RT/on+gHtWs5jj7zW5Uf/B95bSs/m7jgdAAAAABJRU5ErkJggg==",
      "text/latex": [
       "$\\displaystyle \\frac{\\left(r \\left(r y - x \\sqrt{- r^{2} + x^{2} + y^{2}}\\right) - y \\left(x^{2} + y^{2}\\right)\\right) \\left(r \\left(r y + x \\sqrt{- r^{2} + x^{2} + y^{2}}\\right) - y \\left(x^{2} + y^{2}\\right)\\right)}{\\left(r \\left(r x - y \\sqrt{- r^{2} + x^{2} + y^{2}}\\right) - x \\left(x^{2} + y^{2}\\right)\\right) \\left(r \\left(r x + y \\sqrt{- r^{2} + x^{2} + y^{2}}\\right) - x \\left(x^{2} + y^{2}\\right)\\right)}$"
      ],
      "text/plain": [
       "⎛  ⎛           ________________⎞              ⎞ ⎛  ⎛           _______________\n",
       "⎜  ⎜          ╱    2    2    2 ⎟     ⎛ 2    2⎞⎟ ⎜  ⎜          ╱    2    2    2\n",
       "⎝r⋅⎝r⋅y - x⋅╲╱  - r  + x  + y  ⎠ - y⋅⎝x  + y ⎠⎠⋅⎝r⋅⎝r⋅y + x⋅╲╱  - r  + x  + y \n",
       "──────────────────────────────────────────────────────────────────────────────\n",
       "⎛  ⎛           ________________⎞              ⎞ ⎛  ⎛           _______________\n",
       "⎜  ⎜          ╱    2    2    2 ⎟     ⎛ 2    2⎞⎟ ⎜  ⎜          ╱    2    2    2\n",
       "⎝r⋅⎝r⋅x - y⋅╲╱  - r  + x  + y  ⎠ - x⋅⎝x  + y ⎠⎠⋅⎝r⋅⎝r⋅x + y⋅╲╱  - r  + x  + y \n",
       "\n",
       "_⎞              ⎞\n",
       " ⎟     ⎛ 2    2⎞⎟\n",
       " ⎠ - y⋅⎝x  + y ⎠⎠\n",
       "─────────────────\n",
       "_⎞              ⎞\n",
       " ⎟     ⎛ 2    2⎞⎟\n",
       " ⎠ - x⋅⎝x  + y ⎠⎠"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1.slope*l2.slope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "checks=simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADwAAAAkCAYAAADVeVmEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABJ0AAASdAHeZh94AAAC8UlEQVR4nO3YT4hVZRjH8Y+iCLVLalW0CFpINFNYgVmQEGW0KLQ/FNFCgshFEK4k+vksTCKw7A8EbUxbRIVtphACCSKniChGEMqM/rkpUSgkqOi2uEe5DNqdc+aONdP8Nufeh/M83/c57znve85vSa/XMypV1WXYi0vwByrJvpEBRsBfOmLmn3g8ySrcil1VdcGIGbPiLxnlDE9XVU3hziTfzxmkJX/UMzwIW43l+GGuGF34I2u4qpYP/F6JPdiUZOgtVFW7q2rbCMdyTv6yjgUv1b9yD+JR3IBHsKeqVuAd7EhycDYDPwv3R+xMsnMgNo5PcE2Sw8P4nRrGeHPcgq04gpNVtQS7cSDJ3o61/0mTuG5a7Dm82jQ7lN+14TH8ho1JvjkdrKq1uA9TVXVXE34oyaGOnOmaxGMDvA3NWDY2oRuH8c+s0s0zlCHAW5J8UFVvoZfk3i6jrqqt+nfGaa1AD78PxNYn+XBa3hp8hJU4hcN4McnzM2UPzvBLeGPI+aeX9zHMGHIWvYI3B/4/g2N4YSB27Cx5n+lflNW4Vv/l4uU24Nb7cFVdiF+wNslkq+Rz19yNb5Nsm8G5H+NTPIwHkky0YXXZlq5ujlMdckehSWzGZNtm6dbwGI4kOdUhdxT6An/hiS7Jc/pqOReqqvfxVZLNXfK7bkvnVVW1FBdjE65Cp92BedIwbsYBfIkNSU52LTTvbunZas6+lv6rWmx4oWsZVNX/5kEe6aK1aOItmnjnV4smnkUTb8YF/y0T7x68jiuTfNfEduEOrEny8zB+1xkeb45b8DRWYeI8mHhv4xCehKragvtxe9PswjLxkvQaP+zdqjqq74utS3K0OWVhmXgD+Qdxvf4KvL8Ne76ZeKpqXcNfip/ags80nOQ4jg9LaEy8K/B5W9gA6wRODNT8FSeSfD2EPYZ9+t703diO9W3Y88bEq6rL8R6eTfIansJtVXVTmzrzwsSrqouwHxNJtkOSKf1Ve0ebWouOx0LX32Cqo7YG76TOAAAAAElFTkSuQmCC",
      "text/latex": [
       "$\\displaystyle \\frac{- r^{2} + y^{2}}{- r^{2} + x^{2}}$"
      ],
      "text/plain": [
       "   2    2\n",
       "- r  + y \n",
       "─────────\n",
       "   2    2\n",
       "- r  + x "
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Python 3.12's help utility! If this is your first time using\n",
      "Python, you should definitely check out the tutorial at\n",
      "https://docs.python.org/3.12/tutorial/.\n",
      "\n",
      "Enter the name of any module, keyword, or topic to get help on writing\n",
      "Python programs and using Python modules.  To get a list of available\n",
      "modules, keywords, symbols, or topics, enter \"modules\", \"keywords\",\n",
      "\"symbols\", or \"topics\".\n",
      "\n",
      "Each module also comes with a one-line summary of what it does; to list\n",
      "the modules whose name or summary contain a given string such as \"spam\",\n",
      "enter \"modules spam\".\n",
      "\n",
      "To quit this help utility and return to the interpreter,\n",
      "enter \"q\" or \"quit\".\n",
      "\n",
      "\n",
      "You are now leaving help and returning to the Python interpreter.\n",
      "If you want to ask for help on a particular object directly from the\n",
      "interpreter, you can type \"help(object)\".  Executing \"help('string')\"\n",
      "has the same effect as typing a particular string at the help> prompt.\n"
     ]
    }
   ],
   "source": [
    "from sympy.functions.special.tensor_functions import KroneckerDelta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class KroneckerDelta in module sympy.functions.special.tensor_functions:\n",
      "\n",
      "class KroneckerDelta(sympy.core.function.Function)\n",
      " |  KroneckerDelta(i, j, delta_range=None)\n",
      " |\n",
      " |  The discrete, or Kronecker, delta function.\n",
      " |\n",
      " |  Explanation\n",
      " |  ===========\n",
      " |\n",
      " |  A function that takes in two integers $i$ and $j$. It returns $0$ if $i$\n",
      " |  and $j$ are not equal, or it returns $1$ if $i$ and $j$ are equal.\n",
      " |\n",
      " |  Examples\n",
      " |  ========\n",
      " |\n",
      " |  An example with integer indices:\n",
      " |\n",
      " |      >>> from sympy import KroneckerDelta\n",
      " |      >>> KroneckerDelta(1, 2)\n",
      " |      0\n",
      " |      >>> KroneckerDelta(3, 3)\n",
      " |      1\n",
      " |\n",
      " |  Symbolic indices:\n",
      " |\n",
      " |      >>> from sympy.abc import i, j, k\n",
      " |      >>> KroneckerDelta(i, j)\n",
      " |      KroneckerDelta(i, j)\n",
      " |      >>> KroneckerDelta(i, i)\n",
      " |      1\n",
      " |      >>> KroneckerDelta(i, i + 1)\n",
      " |      0\n",
      " |      >>> KroneckerDelta(i, i + 1 + k)\n",
      " |      KroneckerDelta(i, i + k + 1)\n",
      " |\n",
      " |  Parameters\n",
      " |  ==========\n",
      " |\n",
      " |  i : Number, Symbol\n",
      " |      The first index of the delta function.\n",
      " |  j : Number, Symbol\n",
      " |      The second index of the delta function.\n",
      " |\n",
      " |  See Also\n",
      " |  ========\n",
      " |\n",
      " |  eval\n",
      " |  DiracDelta\n",
      " |\n",
      " |  References\n",
      " |  ==========\n",
      " |\n",
      " |  .. [1] https://en.wikipedia.org/wiki/Kronecker_delta\n",
      " |\n",
      " |  Method resolution order:\n",
      " |      KroneckerDelta\n",
      " |      sympy.core.function.Function\n",
      " |      sympy.core.function.Application\n",
      " |      sympy.core.expr.Expr\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |\n",
      " |  Class methods defined here:\n",
      " |\n",
      " |  eval(i, j, delta_range=None)\n",
      " |      Evaluates the discrete delta function.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import KroneckerDelta\n",
      " |      >>> from sympy.abc import i, j, k\n",
      " |\n",
      " |      >>> KroneckerDelta(i, j)\n",
      " |      KroneckerDelta(i, j)\n",
      " |      >>> KroneckerDelta(i, i)\n",
      " |      1\n",
      " |      >>> KroneckerDelta(i, i + 1)\n",
      " |      0\n",
      " |      >>> KroneckerDelta(i, i + 1 + k)\n",
      " |      KroneckerDelta(i, i + k + 1)\n",
      " |\n",
      " |      # indirect doctest\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |\n",
      " |  delta_range\n",
      " |\n",
      " |  indices\n",
      " |\n",
      " |  indices_contain_equal_information\n",
      " |      Returns True if indices are either both above or below fermi.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import KroneckerDelta, Symbol\n",
      " |      >>> a = Symbol('a', above_fermi=True)\n",
      " |      >>> i = Symbol('i', below_fermi=True)\n",
      " |      >>> p = Symbol('p')\n",
      " |      >>> q = Symbol('q')\n",
      " |      >>> KroneckerDelta(p, q).indices_contain_equal_information\n",
      " |      True\n",
      " |      >>> KroneckerDelta(p, q+1).indices_contain_equal_information\n",
      " |      True\n",
      " |      >>> KroneckerDelta(i, p).indices_contain_equal_information\n",
      " |      False\n",
      " |\n",
      " |  is_above_fermi\n",
      " |      True if Delta can be non-zero above fermi.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import KroneckerDelta, Symbol\n",
      " |      >>> a = Symbol('a', above_fermi=True)\n",
      " |      >>> i = Symbol('i', below_fermi=True)\n",
      " |      >>> p = Symbol('p')\n",
      " |      >>> q = Symbol('q')\n",
      " |      >>> KroneckerDelta(p, a).is_above_fermi\n",
      " |      True\n",
      " |      >>> KroneckerDelta(p, i).is_above_fermi\n",
      " |      False\n",
      " |      >>> KroneckerDelta(p, q).is_above_fermi\n",
      " |      True\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      is_below_fermi, is_only_below_fermi, is_only_above_fermi\n",
      " |\n",
      " |  is_below_fermi\n",
      " |      True if Delta can be non-zero below fermi.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import KroneckerDelta, Symbol\n",
      " |      >>> a = Symbol('a', above_fermi=True)\n",
      " |      >>> i = Symbol('i', below_fermi=True)\n",
      " |      >>> p = Symbol('p')\n",
      " |      >>> q = Symbol('q')\n",
      " |      >>> KroneckerDelta(p, a).is_below_fermi\n",
      " |      False\n",
      " |      >>> KroneckerDelta(p, i).is_below_fermi\n",
      " |      True\n",
      " |      >>> KroneckerDelta(p, q).is_below_fermi\n",
      " |      True\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      is_above_fermi, is_only_above_fermi, is_only_below_fermi\n",
      " |\n",
      " |  is_only_above_fermi\n",
      " |      True if Delta is restricted to above fermi.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import KroneckerDelta, Symbol\n",
      " |      >>> a = Symbol('a', above_fermi=True)\n",
      " |      >>> i = Symbol('i', below_fermi=True)\n",
      " |      >>> p = Symbol('p')\n",
      " |      >>> q = Symbol('q')\n",
      " |      >>> KroneckerDelta(p, a).is_only_above_fermi\n",
      " |      True\n",
      " |      >>> KroneckerDelta(p, q).is_only_above_fermi\n",
      " |      False\n",
      " |      >>> KroneckerDelta(p, i).is_only_above_fermi\n",
      " |      False\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      is_above_fermi, is_below_fermi, is_only_below_fermi\n",
      " |\n",
      " |  is_only_below_fermi\n",
      " |      True if Delta is restricted to below fermi.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import KroneckerDelta, Symbol\n",
      " |      >>> a = Symbol('a', above_fermi=True)\n",
      " |      >>> i = Symbol('i', below_fermi=True)\n",
      " |      >>> p = Symbol('p')\n",
      " |      >>> q = Symbol('q')\n",
      " |      >>> KroneckerDelta(p, i).is_only_below_fermi\n",
      " |      True\n",
      " |      >>> KroneckerDelta(p, q).is_only_below_fermi\n",
      " |      False\n",
      " |      >>> KroneckerDelta(p, a).is_only_below_fermi\n",
      " |      False\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      is_above_fermi, is_below_fermi, is_only_above_fermi\n",
      " |\n",
      " |  killable_index\n",
      " |      Returns the index which is preferred to substitute in the final\n",
      " |      expression.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      The index to substitute is the index with less information regarding\n",
      " |      fermi level. If indices contain the same information, 'a' is preferred\n",
      " |      before 'b'.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import KroneckerDelta, Symbol\n",
      " |      >>> a = Symbol('a', above_fermi=True)\n",
      " |      >>> i = Symbol('i', below_fermi=True)\n",
      " |      >>> j = Symbol('j', below_fermi=True)\n",
      " |      >>> p = Symbol('p')\n",
      " |      >>> KroneckerDelta(p, i).killable_index\n",
      " |      p\n",
      " |      >>> KroneckerDelta(p, a).killable_index\n",
      " |      p\n",
      " |      >>> KroneckerDelta(i, j).killable_index\n",
      " |      j\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      preferred_index\n",
      " |\n",
      " |  preferred_index\n",
      " |      Returns the index which is preferred to keep in the final expression.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      The preferred index is the index with more information regarding fermi\n",
      " |      level. If indices contain the same information, 'a' is preferred before\n",
      " |      'b'.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import KroneckerDelta, Symbol\n",
      " |      >>> a = Symbol('a', above_fermi=True)\n",
      " |      >>> i = Symbol('i', below_fermi=True)\n",
      " |      >>> j = Symbol('j', below_fermi=True)\n",
      " |      >>> p = Symbol('p')\n",
      " |      >>> KroneckerDelta(p, i).preferred_index\n",
      " |      i\n",
      " |      >>> KroneckerDelta(p, a).preferred_index\n",
      " |      a\n",
      " |      >>> KroneckerDelta(i, j).preferred_index\n",
      " |      i\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      killable_index\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |\n",
      " |  __annotations__ = {}\n",
      " |\n",
      " |  default_assumptions = {'integer': True, 'irrational': False, 'noninteg...\n",
      " |\n",
      " |  is_algebraic = True\n",
      " |\n",
      " |  is_commutative = True\n",
      " |\n",
      " |  is_complex = True\n",
      " |\n",
      " |  is_extended_real = True\n",
      " |\n",
      " |  is_finite = True\n",
      " |\n",
      " |  is_hermitian = True\n",
      " |\n",
      " |  is_imaginary = False\n",
      " |\n",
      " |  is_infinite = False\n",
      " |\n",
      " |  is_integer = True\n",
      " |\n",
      " |  is_irrational = False\n",
      " |\n",
      " |  is_noninteger = False\n",
      " |\n",
      " |  is_rational = True\n",
      " |\n",
      " |  is_real = True\n",
      " |\n",
      " |  is_transcendental = False\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.function.Function:\n",
      " |\n",
      " |  as_base_exp(self)\n",
      " |      Returns the method as the 2-tuple (base, exponent).\n",
      " |\n",
      " |  fdiff(self, argindex=1)\n",
      " |      Returns the first derivative of the function.\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.function.Function:\n",
      " |\n",
      " |  class_key()\n",
      " |      Nice order of classes.\n",
      " |\n",
      " |  is_singular(a)\n",
      " |      Tests whether the argument is an essential singularity\n",
      " |      or a branch point, or the functions is non-holomorphic.\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from sympy.core.function.Function:\n",
      " |\n",
      " |  __new__(cls, *args, **options)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.function.Application:\n",
      " |\n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |\n",
      " |      The following should hold for all objects::\n",
      " |\n",
      " |          >> x == x.func(*x.args)\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from sympy.core.function.Application:\n",
      " |\n",
      " |  __dict__\n",
      " |      dictionary for instance variables\n",
      " |\n",
      " |  __weakref__\n",
      " |      list of weak references to the object\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.function.Application:\n",
      " |\n",
      " |  is_Function = True\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.expr.Expr:\n",
      " |\n",
      " |  __abs__(self) -> 'Expr'\n",
      " |\n",
      " |  __add__(self, other)\n",
      " |\n",
      " |  __complex__(self)\n",
      " |\n",
      " |  __divmod__(self, other)\n",
      " |\n",
      " |  __float__(self)\n",
      " |\n",
      " |  __floordiv__(self, other)\n",
      " |\n",
      " |  __format__(self, format_spec: 'str')\n",
      " |      Default object formatter.\n",
      " |\n",
      " |      Return str(self) if format_spec is empty. Raise TypeError otherwise.\n",
      " |\n",
      " |  __ge__(self, other)\n",
      " |      Return self>=value.\n",
      " |\n",
      " |  __gt__(self, other)\n",
      " |      Return self>value.\n",
      " |\n",
      " |  __int__(self)\n",
      " |\n",
      " |  __le__(self, other)\n",
      " |      Return self<=value.\n",
      " |\n",
      " |  __lt__(self, other)\n",
      " |      Return self<value.\n",
      " |\n",
      " |  __mod__(self, other)\n",
      " |\n",
      " |  __mul__(self, other)\n",
      " |\n",
      " |  __neg__(self)\n",
      " |\n",
      " |  __pos__(self)\n",
      " |\n",
      " |  __pow__(self, other, mod=None) -> 'Expr'\n",
      " |\n",
      " |  __radd__(self, other)\n",
      " |\n",
      " |  __rdivmod__(self, other)\n",
      " |\n",
      " |  __rfloordiv__(self, other)\n",
      " |\n",
      " |  __rmod__(self, other)\n",
      " |\n",
      " |  __rmul__(self, other)\n",
      " |\n",
      " |  __round__ = round(self, n=None)\n",
      " |\n",
      " |  __rpow__(self, other)\n",
      " |\n",
      " |  __rsub__(self, other)\n",
      " |\n",
      " |  __rtruediv__(self, other)\n",
      " |\n",
      " |  __sub__(self, other)\n",
      " |\n",
      " |  __truediv__(self, other)\n",
      " |\n",
      " |  __trunc__(self)\n",
      " |\n",
      " |  adjoint(self)\n",
      " |\n",
      " |  apart(self, x=None, **args)\n",
      " |      See the apart function in sympy.polys\n",
      " |\n",
      " |  args_cnc(self, cset=False, warn=True, split_1=True)\n",
      " |      Return [commutative factors, non-commutative factors] of self.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      self is treated as a Mul and the ordering of the factors is maintained.\n",
      " |      If ``cset`` is True the commutative factors will be returned in a set.\n",
      " |      If there were repeated factors (as may happen with an unevaluated Mul)\n",
      " |      then an error will be raised unless it is explicitly suppressed by\n",
      " |      setting ``warn`` to False.\n",
      " |\n",
      " |      Note: -1 is always separated from a Number unless split_1 is False.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import symbols, oo\n",
      " |      >>> A, B = symbols('A B', commutative=0)\n",
      " |      >>> x, y = symbols('x y')\n",
      " |      >>> (-2*x*y).args_cnc()\n",
      " |      [[-1, 2, x, y], []]\n",
      " |      >>> (-2.5*x).args_cnc()\n",
      " |      [[-1, 2.5, x], []]\n",
      " |      >>> (-2*x*A*B*y).args_cnc()\n",
      " |      [[-1, 2, x, y], [A, B]]\n",
      " |      >>> (-2*x*A*B*y).args_cnc(split_1=False)\n",
      " |      [[-2, x, y], [A, B]]\n",
      " |      >>> (-2*x*y).args_cnc(cset=True)\n",
      " |      [{-1, 2, x, y}, []]\n",
      " |\n",
      " |      The arg is always treated as a Mul:\n",
      " |\n",
      " |      >>> (-2 + x + A).args_cnc()\n",
      " |      [[], [x - 2 + A]]\n",
      " |      >>> (-oo).args_cnc() # -oo is a singleton\n",
      " |      [[-1, oo], []]\n",
      " |\n",
      " |  as_coeff_Add(self, rational=False) -> \"tuple['Number', Expr]\"\n",
      " |      Efficiently extract the coefficient of a summation.\n",
      " |\n",
      " |  as_coeff_Mul(self, rational: 'bool' = False) -> \"tuple['Number', Expr]\"\n",
      " |      Efficiently extract the coefficient of a product.\n",
      " |\n",
      " |  as_coeff_add(self, *deps) -> 'tuple[Expr, tuple[Expr, ...]]'\n",
      " |      Return the tuple (c, args) where self is written as an Add, ``a``.\n",
      " |\n",
      " |      c should be a Rational added to any terms of the Add that are\n",
      " |      independent of deps.\n",
      " |\n",
      " |      args should be a tuple of all other terms of ``a``; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |\n",
      " |      This should be used when you do not know if self is an Add or not but\n",
      " |      you want to treat self as an Add or if you want to process the\n",
      " |      individual arguments of the tail of self as an Add.\n",
      " |\n",
      " |      - if you know self is an Add and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail.\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |\n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_add()\n",
      " |      (3, ())\n",
      " |      >>> (3 + x).as_coeff_add()\n",
      " |      (3, (x,))\n",
      " |      >>> (3 + x + y).as_coeff_add(x)\n",
      " |      (y + 3, (x,))\n",
      " |      >>> (3 + y).as_coeff_add(x)\n",
      " |      (y + 3, ())\n",
      " |\n",
      " |  as_coeff_exponent(self, x) -> 'tuple[Expr, Expr]'\n",
      " |      ``c*x**e -> c,e`` where x can be any symbolic expression.\n",
      " |\n",
      " |  as_coeff_mul(self, *deps, **kwargs) -> 'tuple[Expr, tuple[Expr, ...]]'\n",
      " |      Return the tuple (c, args) where self is written as a Mul, ``m``.\n",
      " |\n",
      " |      c should be a Rational multiplied by any factors of the Mul that are\n",
      " |      independent of deps.\n",
      " |\n",
      " |      args should be a tuple of all other factors of m; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |\n",
      " |      This should be used when you do not know if self is a Mul or not but\n",
      " |      you want to treat self as a Mul or if you want to process the\n",
      " |      individual arguments of the tail of self as a Mul.\n",
      " |\n",
      " |      - if you know self is a Mul and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail;\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |\n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_mul()\n",
      " |      (3, ())\n",
      " |      >>> (3*x*y).as_coeff_mul()\n",
      " |      (3, (x, y))\n",
      " |      >>> (3*x*y).as_coeff_mul(x)\n",
      " |      (3*y, (x,))\n",
      " |      >>> (3*y).as_coeff_mul(x)\n",
      " |      (3*y, ())\n",
      " |\n",
      " |  as_coefficient(self, expr)\n",
      " |      Extracts symbolic coefficient at the given expression. In\n",
      " |      other words, this functions separates 'self' into the product\n",
      " |      of 'expr' and 'expr'-free coefficient. If such separation\n",
      " |      is not possible it will return None.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import E, pi, sin, I, Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |\n",
      " |      >>> E.as_coefficient(E)\n",
      " |      1\n",
      " |      >>> (2*E).as_coefficient(E)\n",
      " |      2\n",
      " |      >>> (2*sin(E)*E).as_coefficient(E)\n",
      " |\n",
      " |      Two terms have E in them so a sum is returned. (If one were\n",
      " |      desiring the coefficient of the term exactly matching E then\n",
      " |      the constant from the returned expression could be selected.\n",
      " |      Or, for greater precision, a method of Poly can be used to\n",
      " |      indicate the desired term from which the coefficient is\n",
      " |      desired.)\n",
      " |\n",
      " |      >>> (2*E + x*E).as_coefficient(E)\n",
      " |      x + 2\n",
      " |      >>> _.args[0]  # just want the exact match\n",
      " |      2\n",
      " |      >>> p = Poly(2*E + x*E); p\n",
      " |      Poly(x*E + 2*E, x, E, domain='ZZ')\n",
      " |      >>> p.coeff_monomial(E)\n",
      " |      2\n",
      " |      >>> p.nth(0, 1)\n",
      " |      2\n",
      " |\n",
      " |      Since the following cannot be written as a product containing\n",
      " |      E as a factor, None is returned. (If the coefficient ``2*x`` is\n",
      " |      desired then the ``coeff`` method should be used.)\n",
      " |\n",
      " |      >>> (2*E*x + x).as_coefficient(E)\n",
      " |      >>> (2*E*x + x).coeff(E)\n",
      " |      2*x\n",
      " |\n",
      " |      >>> (E*(x + 1) + x).as_coefficient(E)\n",
      " |\n",
      " |      >>> (2*pi*I).as_coefficient(pi*I)\n",
      " |      2\n",
      " |      >>> (2*I).as_coefficient(pi*I)\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      coeff: return sum of terms have a given factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |\n",
      " |  as_coefficients_dict(self, *syms)\n",
      " |      Return a dictionary mapping terms to their Rational coefficient.\n",
      " |      Since the dictionary is a defaultdict, inquiries about terms which\n",
      " |      were not present will return a coefficient of 0.\n",
      " |\n",
      " |      If symbols ``syms`` are provided, any multiplicative terms\n",
      " |      independent of them will be considered a coefficient and a\n",
      " |      regular dictionary of syms-dependent generators as keys and\n",
      " |      their corresponding coefficients as values will be returned.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import a, x, y\n",
      " |      >>> (3*x + a*x + 4).as_coefficients_dict()\n",
      " |      {1: 4, x: 3, a*x: 1}\n",
      " |      >>> _[a]\n",
      " |      0\n",
      " |      >>> (3*a*x).as_coefficients_dict()\n",
      " |      {a*x: 3}\n",
      " |      >>> (3*a*x).as_coefficients_dict(x)\n",
      " |      {x: 3*a}\n",
      " |      >>> (3*a*x).as_coefficients_dict(y)\n",
      " |      {1: 3*a*x}\n",
      " |\n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      This method should recursively remove a Rational from all arguments\n",
      " |      and return that (content) and the new self (primitive). The content\n",
      " |      should always be positive and ``Mul(*foo.as_content_primitive()) == foo``.\n",
      " |      The primitive need not be in canonical form and should try to preserve\n",
      " |      the underlying structure if possible (i.e. expand_mul should not be\n",
      " |      applied to self).\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |\n",
      " |      >>> eq = 2 + 2*x + 2*y*(3 + 3*y)\n",
      " |\n",
      " |      The as_content_primitive function is recursive and retains structure:\n",
      " |\n",
      " |      >>> eq.as_content_primitive()\n",
      " |      (2, x + 3*y*(y + 1) + 1)\n",
      " |\n",
      " |      Integer powers will have Rationals extracted from the base:\n",
      " |\n",
      " |      >>> ((2 + 6*x)**2).as_content_primitive()\n",
      " |      (4, (3*x + 1)**2)\n",
      " |      >>> ((2 + 6*x)**(2*y)).as_content_primitive()\n",
      " |      (1, (2*(3*x + 1))**(2*y))\n",
      " |\n",
      " |      Terms may end up joining once their as_content_primitives are added:\n",
      " |\n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (11, x*(y + 1))\n",
      " |      >>> ((3*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (9, x*(y + 1))\n",
      " |      >>> ((3*(z*(1 + y)) + 2.0*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (1, 6.0*x*(y + 1) + 3*z*(y + 1))\n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (121, x**2*(y + 1)**2)\n",
      " |      >>> ((x*(1 + y) + 0.4*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (1, 4.84*x**2*(y + 1)**2)\n",
      " |\n",
      " |      Radical content can also be factored out of the primitive:\n",
      " |\n",
      " |      >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)\n",
      " |      (2, sqrt(2)*(1 + 2*sqrt(5)))\n",
      " |\n",
      " |      If clear=False (default is True) then content will not be removed\n",
      " |      from an Add if it can be distributed to leave one or more\n",
      " |      terms with integer coefficients.\n",
      " |\n",
      " |      >>> (x/2 + y).as_content_primitive()\n",
      " |      (1/2, x + 2*y)\n",
      " |      >>> (x/2 + y).as_content_primitive(clear=False)\n",
      " |      (1, x/2 + y)\n",
      " |\n",
      " |  as_expr(self, *gens)\n",
      " |      Convert a polynomial to a SymPy expression.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |\n",
      " |      >>> f = (x**2 + x*y).as_poly(x, y)\n",
      " |      >>> f.as_expr()\n",
      " |      x**2 + x*y\n",
      " |\n",
      " |      >>> sin(x).as_expr()\n",
      " |      sin(x)\n",
      " |\n",
      " |  as_independent(self, *deps, **hint) -> 'tuple[Expr, Expr]'\n",
      " |      A mostly naive separation of a Mul or Add into arguments that are not\n",
      " |      are dependent on deps. To obtain as complete a separation of variables\n",
      " |      as possible, use a separation method first, e.g.:\n",
      " |\n",
      " |      * separatevars() to change Mul, Add and Pow (including exp) into Mul\n",
      " |      * .expand(mul=True) to change Add or Mul into Add\n",
      " |      * .expand(log=True) to change log expr into an Add\n",
      " |\n",
      " |      The only non-naive thing that is done here is to respect noncommutative\n",
      " |      ordering of variables and to always return (0, 0) for `self` of zero\n",
      " |      regardless of hints.\n",
      " |\n",
      " |      For nonzero `self`, the returned tuple (i, d) has the\n",
      " |      following interpretation:\n",
      " |\n",
      " |      * i will has no variable that appears in deps\n",
      " |      * d will either have terms that contain variables that are in deps, or\n",
      " |        be equal to 0 (when self is an Add) or 1 (when self is a Mul)\n",
      " |      * if self is an Add then self = i + d\n",
      " |      * if self is a Mul then self = i*d\n",
      " |      * otherwise (self, S.One) or (S.One, self) is returned.\n",
      " |\n",
      " |      To force the expression to be treated as an Add, use the hint as_Add=True\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      -- self is an Add\n",
      " |\n",
      " |      >>> from sympy import sin, cos, exp\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |\n",
      " |      >>> (x + x*y).as_independent(x)\n",
      " |      (0, x*y + x)\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x)\n",
      " |      (y + z, 2*x*sin(x) + x)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x, y)\n",
      " |      (z, 2*x*sin(x) + x + y)\n",
      " |\n",
      " |      -- self is a Mul\n",
      " |\n",
      " |      >>> (x*sin(x)*cos(y)).as_independent(x)\n",
      " |      (cos(y), x*sin(x))\n",
      " |\n",
      " |      non-commutative terms cannot always be separated out when self is a Mul\n",
      " |\n",
      " |      >>> from sympy import symbols\n",
      " |      >>> n1, n2, n3 = symbols('n1 n2 n3', commutative=False)\n",
      " |      >>> (n1 + n1*n2).as_independent(n2)\n",
      " |      (n1, n1*n2)\n",
      " |      >>> (n2*n1 + n1*n2).as_independent(n2)\n",
      " |      (0, n1*n2 + n2*n1)\n",
      " |      >>> (n1*n2*n3).as_independent(n1)\n",
      " |      (1, n1*n2*n3)\n",
      " |      >>> (n1*n2*n3).as_independent(n2)\n",
      " |      (n1, n2*n3)\n",
      " |      >>> ((x-n1)*(x-y)).as_independent(x)\n",
      " |      (1, (x - y)*(x - n1))\n",
      " |\n",
      " |      -- self is anything else:\n",
      " |\n",
      " |      >>> (sin(x)).as_independent(x)\n",
      " |      (1, sin(x))\n",
      " |      >>> (sin(x)).as_independent(y)\n",
      " |      (sin(x), 1)\n",
      " |      >>> exp(x+y).as_independent(x)\n",
      " |      (1, exp(x + y))\n",
      " |\n",
      " |      -- force self to be treated as an Add:\n",
      " |\n",
      " |      >>> (3*x).as_independent(x, as_Add=True)\n",
      " |      (0, 3*x)\n",
      " |\n",
      " |      -- force self to be treated as a Mul:\n",
      " |\n",
      " |      >>> (3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x + 3)\n",
      " |      >>> (-3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x - 3)\n",
      " |\n",
      " |      Note how the below differs from the above in making the\n",
      " |      constant on the dep term positive.\n",
      " |\n",
      " |      >>> (y*(-3+x)).as_independent(x)\n",
      " |      (y, x - 3)\n",
      " |\n",
      " |      -- use .as_independent() for true independence testing instead\n",
      " |         of .has(). The former considers only symbols in the free\n",
      " |         symbols while the latter considers all symbols\n",
      " |\n",
      " |      >>> from sympy import Integral\n",
      " |      >>> I = Integral(x, (x, 1, 2))\n",
      " |      >>> I.has(x)\n",
      " |      True\n",
      " |      >>> x in I.free_symbols\n",
      " |      False\n",
      " |      >>> I.as_independent(x) == (I, 1)\n",
      " |      True\n",
      " |      >>> (I + x).as_independent(x) == (I, x)\n",
      " |      True\n",
      " |\n",
      " |      Note: when trying to get independent terms, a separation method\n",
      " |      might need to be used first. In this case, it is important to keep\n",
      " |      track of what you send to this routine so you know how to interpret\n",
      " |      the returned values\n",
      " |\n",
      " |      >>> from sympy import separatevars, log\n",
      " |      >>> separatevars(exp(x+y)).as_independent(x)\n",
      " |      (exp(y), exp(x))\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> separatevars(x + x*y).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).expand(mul=True).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> a, b=symbols('a b', positive=True)\n",
      " |      >>> (log(a*b).expand(log=True)).as_independent(b)\n",
      " |      (log(a), log(b))\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      separatevars\n",
      " |      expand_log\n",
      " |      sympy.core.add.Add.as_two_terms\n",
      " |      sympy.core.mul.Mul.as_two_terms\n",
      " |      as_coeff_mul\n",
      " |\n",
      " |  as_leading_term(self, *symbols, logx=None, cdir=0)\n",
      " |      Returns the leading (nonzero) term of the series expansion of self.\n",
      " |\n",
      " |      The _eval_as_leading_term routines are used to do this, and they must\n",
      " |      always return a non-zero value.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + x**2).as_leading_term(x)\n",
      " |      1\n",
      " |      >>> (1/x**2 + x + x**2).as_leading_term(x)\n",
      " |      x**(-2)\n",
      " |\n",
      " |  as_numer_denom(self)\n",
      " |      Return the numerator and the denominator of an expression.\n",
      " |\n",
      " |      expression -> a/b -> a, b\n",
      " |\n",
      " |      This is just a stub that should be defined by\n",
      " |      an object's class methods to get anything else.\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      normal: return ``a/b`` instead of ``(a, b)``\n",
      " |\n",
      " |  as_ordered_factors(self, order=None)\n",
      " |      Return list of ordered factors (if Mul) else [self].\n",
      " |\n",
      " |  as_ordered_terms(self, order=None, data=False)\n",
      " |      Transform an expression to an ordered list of terms.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import sin, cos\n",
      " |      >>> from sympy.abc import x\n",
      " |\n",
      " |      >>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms()\n",
      " |      [sin(x)**2*cos(x), sin(x)**2, 1]\n",
      " |\n",
      " |  as_poly(self, *gens, **args)\n",
      " |      Converts ``self`` to a polynomial or returns ``None``.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |\n",
      " |      >>> print((x**2 + x*y).as_poly())\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |\n",
      " |      >>> print((x**2 + x*y).as_poly(x, y))\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |\n",
      " |      >>> print((x**2 + sin(y)).as_poly(x, y))\n",
      " |      None\n",
      " |\n",
      " |  as_powers_dict(self)\n",
      " |      Return self as a dictionary of factors with each factor being\n",
      " |      treated as a power. The keys are the bases of the factors and the\n",
      " |      values, the corresponding exponents. The resulting dictionary should\n",
      " |      be used with caution if the expression is a Mul and contains non-\n",
      " |      commutative factors since the order that they appeared will be lost in\n",
      " |      the dictionary.\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |      as_ordered_factors: An alternative for noncommutative applications,\n",
      " |                          returning an ordered list of factors.\n",
      " |      args_cnc: Similar to as_ordered_factors, but guarantees separation\n",
      " |                of commutative and noncommutative factors.\n",
      " |\n",
      " |  as_real_imag(self, deep=True, **hints)\n",
      " |      Performs complex expansion on 'self' and returns a tuple\n",
      " |      containing collected both real and imaginary parts. This\n",
      " |      method cannot be confused with re() and im() functions,\n",
      " |      which does not perform complex expansion at evaluation.\n",
      " |\n",
      " |      However it is possible to expand both re() and im()\n",
      " |      functions and get exactly the same results as with\n",
      " |      a single call to this function.\n",
      " |\n",
      " |      >>> from sympy import symbols, I\n",
      " |\n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |\n",
      " |      >>> (x + y*I).as_real_imag()\n",
      " |      (x, y)\n",
      " |\n",
      " |      >>> from sympy.abc import z, w\n",
      " |\n",
      " |      >>> (z + w*I).as_real_imag()\n",
      " |      (re(z) - im(w), re(w) + im(z))\n",
      " |\n",
      " |  as_terms(self)\n",
      " |      Transform an expression to a list of terms.\n",
      " |\n",
      " |  aseries(self, x=None, n=6, bound=0, hir=False)\n",
      " |      Asymptotic Series expansion of self.\n",
      " |      This is equivalent to ``self.series(x, oo, n)``.\n",
      " |\n",
      " |      Parameters\n",
      " |      ==========\n",
      " |\n",
      " |      self : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |\n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |\n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |\n",
      " |      hir : Boolean\n",
      " |            Set this parameter to be True to produce hierarchical series.\n",
      " |            It stops the recursion at an early level and may provide nicer\n",
      " |            and more useful results.\n",
      " |\n",
      " |      bound : Value, Integer\n",
      " |              Use the ``bound`` parameter to give limit on rewriting\n",
      " |              coefficients in its normalised form.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import sin, exp\n",
      " |      >>> from sympy.abc import x\n",
      " |\n",
      " |      >>> e = sin(1/x + exp(-x)) - sin(1/x)\n",
      " |\n",
      " |      >>> e.aseries(x)\n",
      " |      (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)\n",
      " |\n",
      " |      >>> e.aseries(x, n=3, hir=True)\n",
      " |      -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))\n",
      " |\n",
      " |      >>> e = exp(exp(x)/(1 - 1/x))\n",
      " |\n",
      " |      >>> e.aseries(x)\n",
      " |      exp(exp(x)/(1 - 1/x))\n",
      " |\n",
      " |      >>> e.aseries(x, bound=3) # doctest: +SKIP\n",
      " |      exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))\n",
      " |\n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).aseries(x, n=8)\n",
      " |      1/x\n",
      " |\n",
      " |      Returns\n",
      " |      =======\n",
      " |\n",
      " |      Expr\n",
      " |          Asymptotic series expansion of the expression.\n",
      " |\n",
      " |      Notes\n",
      " |      =====\n",
      " |\n",
      " |      This algorithm is directly induced from the limit computational algorithm provided by Gruntz.\n",
      " |      It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first\n",
      " |      to look for the most rapidly varying subexpression w of a given expression f and then expands f\n",
      " |      in a series in w. Then same thing is recursively done on the leading coefficient\n",
      " |      till we get constant coefficients.\n",
      " |\n",
      " |      If the most rapidly varying subexpression of a given expression f is f itself,\n",
      " |      the algorithm tries to find a normalised representation of the mrv set and rewrites f\n",
      " |      using this normalised representation.\n",
      " |\n",
      " |      If the expansion contains an order term, it will be either ``O(x ** (-n))`` or ``O(w ** (-n))``\n",
      " |      where ``w`` belongs to the most rapidly varying expression of ``self``.\n",
      " |\n",
      " |      References\n",
      " |      ==========\n",
      " |\n",
      " |      .. [1] Gruntz, Dominik. A new algorithm for computing asymptotic series.\n",
      " |             In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993.\n",
      " |             pp. 239-244.\n",
      " |      .. [2] Gruntz thesis - p90\n",
      " |      .. [3] https://en.wikipedia.org/wiki/Asymptotic_expansion\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      Expr.aseries: See the docstring of this function for complete details of this wrapper.\n",
      " |\n",
      " |  cancel(self, *gens, **args)\n",
      " |      See the cancel function in sympy.polys\n",
      " |\n",
      " |  coeff(self, x, n=1, right=False, _first=True)\n",
      " |      Returns the coefficient from the term(s) containing ``x**n``. If ``n``\n",
      " |      is zero then all terms independent of ``x`` will be returned.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      When ``x`` is noncommutative, the coefficient to the left (default) or\n",
      " |      right of ``x`` can be returned. The keyword 'right' is ignored when\n",
      " |      ``x`` is commutative.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import symbols\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |\n",
      " |      You can select terms that have an explicit negative in front of them:\n",
      " |\n",
      " |      >>> (-x + 2*y).coeff(-1)\n",
      " |      x\n",
      " |      >>> (x - 2*y).coeff(-1)\n",
      " |      2*y\n",
      " |\n",
      " |      You can select terms with no Rational coefficient:\n",
      " |\n",
      " |      >>> (x + 2*y).coeff(1)\n",
      " |      x\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(1)\n",
      " |      0\n",
      " |\n",
      " |      You can select terms independent of x by making n=0; in this case\n",
      " |      expr.as_independent(x)[0] is returned (and 0 will be returned instead\n",
      " |      of None):\n",
      " |\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x, 0)\n",
      " |      3\n",
      " |      >>> eq = ((x + 1)**3).expand() + 1\n",
      " |      >>> eq\n",
      " |      x**3 + 3*x**2 + 3*x + 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 2]\n",
      " |      >>> eq -= 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 0]\n",
      " |\n",
      " |      You can select terms that have a numerical term in front of them:\n",
      " |\n",
      " |      >>> (-x - 2*y).coeff(2)\n",
      " |      -y\n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> (x + sqrt(2)*x).coeff(sqrt(2))\n",
      " |      x\n",
      " |\n",
      " |      The matching is exact:\n",
      " |\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x)\n",
      " |      2\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**2)\n",
      " |      4\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**3)\n",
      " |      0\n",
      " |      >>> (z*(x + y)**2).coeff((x + y)**2)\n",
      " |      z\n",
      " |      >>> (z*(x + y)**2).coeff(x + y)\n",
      " |      0\n",
      " |\n",
      " |      In addition, no factoring is done, so 1 + z*(1 + y) is not obtained\n",
      " |      from the following:\n",
      " |\n",
      " |      >>> (x + z*(x + x*y)).coeff(x)\n",
      " |      1\n",
      " |\n",
      " |      If such factoring is desired, factor_terms can be used first:\n",
      " |\n",
      " |      >>> from sympy import factor_terms\n",
      " |      >>> factor_terms(x + z*(x + x*y)).coeff(x)\n",
      " |      z*(y + 1) + 1\n",
      " |\n",
      " |      >>> n, m, o = symbols('n m o', commutative=False)\n",
      " |      >>> n.coeff(n)\n",
      " |      1\n",
      " |      >>> (3*n).coeff(n)\n",
      " |      3\n",
      " |      >>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m\n",
      " |      1 + m\n",
      " |      >>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m\n",
      " |      m\n",
      " |\n",
      " |      If there is more than one possible coefficient 0 is returned:\n",
      " |\n",
      " |      >>> (n*m + m*n).coeff(n)\n",
      " |      0\n",
      " |\n",
      " |      If there is only one possible coefficient, it is returned:\n",
      " |\n",
      " |      >>> (n*m + x*m*n).coeff(m*n)\n",
      " |      x\n",
      " |      >>> (n*m + x*m*n).coeff(m*n, right=1)\n",
      " |      1\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      as_coefficient: separate the expression into a coefficient and factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |\n",
      " |  collect(self, syms, func=None, evaluate=True, exact=False, distribute_order_term=True)\n",
      " |      See the collect function in sympy.simplify\n",
      " |\n",
      " |  combsimp(self)\n",
      " |      See the combsimp function in sympy.simplify\n",
      " |\n",
      " |  compute_leading_term(self, x, logx=None)\n",
      " |      Deprecated function to compute the leading term of a series.\n",
      " |\n",
      " |      as_leading_term is only allowed for results of .series()\n",
      " |      This is a wrapper to compute a series first.\n",
      " |\n",
      " |  conjugate(self)\n",
      " |      Returns the complex conjugate of 'self'.\n",
      " |\n",
      " |  could_extract_minus_sign(self)\n",
      " |      Return True if self has -1 as a leading factor or has\n",
      " |      more literal negative signs than positive signs in a sum,\n",
      " |      otherwise False.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = x - y\n",
      " |      >>> {i.could_extract_minus_sign() for i in (e, -e)}\n",
      " |      {False, True}\n",
      " |\n",
      " |      Though the ``y - x`` is considered like ``-(x - y)``, since it\n",
      " |      is in a product without a leading factor of -1, the result is\n",
      " |      false below:\n",
      " |\n",
      " |      >>> (x*(y - x)).could_extract_minus_sign()\n",
      " |      False\n",
      " |\n",
      " |      To put something in canonical form wrt to sign, use `signsimp`:\n",
      " |\n",
      " |      >>> from sympy import signsimp\n",
      " |      >>> signsimp(x*(y - x))\n",
      " |      -x*(x - y)\n",
      " |      >>> _.could_extract_minus_sign()\n",
      " |      True\n",
      " |\n",
      " |  count_ops(self, visual=None)\n",
      " |      Wrapper for count_ops that returns the operation count.\n",
      " |\n",
      " |  diff(self, *symbols, **assumptions)\n",
      " |\n",
      " |  dir(self, x, cdir)\n",
      " |\n",
      " |  equals(self, other, failing_expression=False)\n",
      " |      Return True if self == other, False if it does not, or None. If\n",
      " |      failing_expression is True then the expression which did not simplify\n",
      " |      to a 0 will be returned instead of None.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      If ``self`` is a Number (or complex number) that is not zero, then\n",
      " |      the result is False.\n",
      " |\n",
      " |      If ``self`` is a number and has not evaluated to zero, evalf will be\n",
      " |      used to test whether the expression evaluates to zero. If it does so\n",
      " |      and the result has significance (i.e. the precision is either -1, for\n",
      " |      a Rational result, or is greater than 1) then the evalf value will be\n",
      " |      used to return True or False.\n",
      " |\n",
      " |  expand(self, deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)\n",
      " |      Expand an expression using hints.\n",
      " |\n",
      " |      See the docstring of the expand() function in sympy.core.function for\n",
      " |      more information.\n",
      " |\n",
      " |  extract_additively(self, c)\n",
      " |      Return self - c if it's possible to subtract c from self and\n",
      " |      make all matching coefficients move towards zero, else return None.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = 2*x + 3\n",
      " |      >>> e.extract_additively(x + 1)\n",
      " |      x + 2\n",
      " |      >>> e.extract_additively(3*x)\n",
      " |      >>> e.extract_additively(4)\n",
      " |      >>> (y*(x + 1)).extract_additively(x + 1)\n",
      " |      >>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1)\n",
      " |      (x + 1)*(x + 2*y) + 3\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |      extract_multiplicatively\n",
      " |      coeff\n",
      " |      as_coefficient\n",
      " |\n",
      " |  extract_branch_factor(self, allow_half=False)\n",
      " |      Try to write self as ``exp_polar(2*pi*I*n)*z`` in a nice way.\n",
      " |      Return (z, n).\n",
      " |\n",
      " |      >>> from sympy import exp_polar, I, pi\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> exp_polar(I*pi).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), 0)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor()\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(-pi*I).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), -1)\n",
      " |      >>> exp_polar(3*pi*I + x).extract_branch_factor()\n",
      " |      (exp_polar(x + I*pi), 1)\n",
      " |      >>> (y*exp_polar(-5*pi*I)*exp_polar(3*pi*I + 2*pi*x)).extract_branch_factor()\n",
      " |      (y*exp_polar(2*pi*x), -1)\n",
      " |      >>> exp_polar(-I*pi/2).extract_branch_factor()\n",
      " |      (exp_polar(-I*pi/2), 0)\n",
      " |\n",
      " |      If allow_half is True, also extract exp_polar(I*pi):\n",
      " |\n",
      " |      >>> exp_polar(I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1/2)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(3*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 3/2)\n",
      " |      >>> exp_polar(-I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, -1/2)\n",
      " |\n",
      " |  extract_multiplicatively(self, c)\n",
      " |      Return None if it's not possible to make self in the form\n",
      " |      c * something in a nice way, i.e. preserving the properties\n",
      " |      of arguments of self.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import symbols, Rational\n",
      " |\n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |\n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**2 * y)\n",
      " |      x*y**2\n",
      " |\n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**4 * y)\n",
      " |\n",
      " |      >>> (2*x).extract_multiplicatively(2)\n",
      " |      x\n",
      " |\n",
      " |      >>> (2*x).extract_multiplicatively(3)\n",
      " |\n",
      " |      >>> (Rational(1, 2)*x).extract_multiplicatively(3)\n",
      " |      x/6\n",
      " |\n",
      " |  factor(self, *gens, **args)\n",
      " |      See the factor() function in sympy.polys.polytools\n",
      " |\n",
      " |  fourier_series(self, limits=None)\n",
      " |      Compute fourier sine/cosine series of self.\n",
      " |\n",
      " |      See the docstring of the :func:`fourier_series` in sympy.series.fourier\n",
      " |      for more information.\n",
      " |\n",
      " |  fps(self, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)\n",
      " |      Compute formal power power series of self.\n",
      " |\n",
      " |      See the docstring of the :func:`fps` function in sympy.series.formal for\n",
      " |      more information.\n",
      " |\n",
      " |  gammasimp(self)\n",
      " |      See the gammasimp function in sympy.simplify\n",
      " |\n",
      " |  getO(self)\n",
      " |      Returns the additive O(..) symbol if there is one, else None.\n",
      " |\n",
      " |  getn(self)\n",
      " |      Returns the order of the expression.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      The order is determined either from the O(...) term. If there\n",
      " |      is no O(...) term, it returns None.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import O\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + O(x**2)).getn()\n",
      " |      2\n",
      " |      >>> (1 + x).getn()\n",
      " |\n",
      " |  integrate(self, *args, **kwargs)\n",
      " |      See the integrate function in sympy.integrals\n",
      " |\n",
      " |  invert(self, g, *gens, **args)\n",
      " |      Return the multiplicative inverse of ``self`` mod ``g``\n",
      " |      where ``self`` (and ``g``) may be symbolic expressions).\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |      sympy.core.numbers.mod_inverse, sympy.polys.polytools.invert\n",
      " |\n",
      " |  is_algebraic_expr(self, *syms)\n",
      " |      This tests whether a given expression is algebraic or not, in the\n",
      " |      given symbols, syms. When syms is not given, all free symbols\n",
      " |      will be used. The rational function does not have to be in expanded\n",
      " |      or in any kind of canonical form.\n",
      " |\n",
      " |      This function returns False for expressions that are \"algebraic\n",
      " |      expressions\" with symbolic exponents. This is a simple extension to the\n",
      " |      is_rational_function, including rational exponentiation.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Symbol, sqrt\n",
      " |      >>> x = Symbol('x', real=True)\n",
      " |      >>> sqrt(1 + x).is_rational_function()\n",
      " |      False\n",
      " |      >>> sqrt(1 + x).is_algebraic_expr()\n",
      " |      True\n",
      " |\n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be an algebraic\n",
      " |      expression to become one.\n",
      " |\n",
      " |      >>> from sympy import exp, factor\n",
      " |      >>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1)\n",
      " |      >>> a.is_algebraic_expr(x)\n",
      " |      False\n",
      " |      >>> factor(a).is_algebraic_expr()\n",
      " |      True\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      is_rational_function\n",
      " |\n",
      " |      References\n",
      " |      ==========\n",
      " |\n",
      " |      .. [1] https://en.wikipedia.org/wiki/Algebraic_expression\n",
      " |\n",
      " |  is_constant(self, *wrt, **flags)\n",
      " |      Return True if self is constant, False if not, or None if\n",
      " |      the constancy could not be determined conclusively.\n",
      " |\n",
      " |      Explanation\n",
      " |      ===========\n",
      " |\n",
      " |      If an expression has no free symbols then it is a constant. If\n",
      " |      there are free symbols it is possible that the expression is a\n",
      " |      constant, perhaps (but not necessarily) zero. To test such\n",
      " |      expressions, a few strategies are tried:\n",
      " |\n",
      " |      1) numerical evaluation at two random points. If two such evaluations\n",
      " |      give two different values and the values have a precision greater than\n",
      " |      1 then self is not constant. If the evaluations agree or could not be\n",
      " |      obtained with any precision, no decision is made. The numerical testing\n",
      " |      is done only if ``wrt`` is different than the free symbols.\n",
      " |\n",
      " |      2) differentiation with respect to variables in 'wrt' (or all free\n",
      " |      symbols if omitted) to see if the expression is constant or not. This\n",
      " |      will not always lead to an expression that is zero even though an\n",
      " |      expression is constant (see added test in test_expr.py). If\n",
      " |      all derivatives are zero then self is constant with respect to the\n",
      " |      given symbols.\n",
      " |\n",
      " |      3) finding out zeros of denominator expression with free_symbols.\n",
      " |      It will not be constant if there are zeros. It gives more negative\n",
      " |      answers for expression that are not constant.\n",
      " |\n",
      " |      If neither evaluation nor differentiation can prove the expression is\n",
      " |      constant, None is returned unless two numerical values happened to be\n",
      " |      the same and the flag ``failing_number`` is True -- in that case the\n",
      " |      numerical value will be returned.\n",
      " |\n",
      " |      If flag simplify=False is passed, self will not be simplified;\n",
      " |      the default is True since self should be simplified before testing.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import cos, sin, Sum, S, pi\n",
      " |      >>> from sympy.abc import a, n, x, y\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> S(2).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, 10)).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant()\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(y)\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(n)\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(x)\n",
      " |      True\n",
      " |      >>> eq = a*cos(x)**2 + a*sin(x)**2 - a\n",
      " |      >>> eq.is_constant()\n",
      " |      True\n",
      " |      >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0\n",
      " |      True\n",
      " |\n",
      " |      >>> (0**x).is_constant()\n",
      " |      False\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> (x**x).is_constant()\n",
      " |      False\n",
      " |      >>> one = cos(x)**2 + sin(x)**2\n",
      " |      >>> one.is_constant()\n",
      " |      True\n",
      " |      >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1\n",
      " |      True\n",
      " |\n",
      " |  is_meromorphic(self, x, a)\n",
      " |      This tests whether an expression is meromorphic as\n",
      " |      a function of the given symbol ``x`` at the point ``a``.\n",
      " |\n",
      " |      This method is intended as a quick test that will return\n",
      " |      None if no decision can be made without simplification or\n",
      " |      more detailed analysis.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import zoo, log, sin, sqrt\n",
      " |      >>> from sympy.abc import x\n",
      " |\n",
      " |      >>> f = 1/x**2 + 1 - 2*x**3\n",
      " |      >>> f.is_meromorphic(x, 0)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |\n",
      " |      >>> g = x**log(3)\n",
      " |      >>> g.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> g.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> g.is_meromorphic(x, zoo)\n",
      " |      False\n",
      " |\n",
      " |      >>> h = sin(1/x)*x**2\n",
      " |      >>> h.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> h.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> h.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |\n",
      " |      Multivalued functions are considered meromorphic when their\n",
      " |      branches are meromorphic. Thus most functions are meromorphic\n",
      " |      everywhere except at essential singularities and branch points.\n",
      " |      In particular, they will be meromorphic also on branch cuts\n",
      " |      except at their endpoints.\n",
      " |\n",
      " |      >>> log(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> log(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> sqrt(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> sqrt(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |\n",
      " |  is_polynomial(self, *syms)\n",
      " |      Return True if self is a polynomial in syms and False otherwise.\n",
      " |\n",
      " |      This checks if self is an exact polynomial in syms.  This function\n",
      " |      returns False for expressions that are \"polynomials\" with symbolic\n",
      " |      exponents.  Thus, you should be able to apply polynomial algorithms to\n",
      " |      expressions for which this returns True, and Poly(expr, \\*syms) should\n",
      " |      work if and only if expr.is_polynomial(\\*syms) returns True. The\n",
      " |      polynomial does not have to be in expanded form.  If no symbols are\n",
      " |      given, all free symbols in the expression will be used.\n",
      " |\n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', polynomial=True).\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Symbol, Function\n",
      " |      >>> x = Symbol('x')\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial(x)\n",
      " |      True\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial()\n",
      " |      True\n",
      " |      >>> (2**x + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (2**x + 1).is_polynomial(2**x)\n",
      " |      True\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (f(x) + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (f(x) + 1).is_polynomial(f(x))\n",
      " |      True\n",
      " |      >>> (1/f(x) + 1).is_polynomial(f(x))\n",
      " |      False\n",
      " |\n",
      " |      >>> n = Symbol('n', nonnegative=True, integer=True)\n",
      " |      >>> (x**n + 1).is_polynomial(x)\n",
      " |      False\n",
      " |\n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a polynomial to\n",
      " |      become one.\n",
      " |\n",
      " |      >>> from sympy import sqrt, factor, cancel\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)\n",
      " |      >>> a.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      y + 1\n",
      " |      >>> factor(a).is_polynomial(y)\n",
      " |      True\n",
      " |\n",
      " |      >>> b = (y**2 + 2*y + 1)/(y + 1)\n",
      " |      >>> b.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> cancel(b)\n",
      " |      y + 1\n",
      " |      >>> cancel(b).is_polynomial(y)\n",
      " |      True\n",
      " |\n",
      " |      See also .is_rational_function()\n",
      " |\n",
      " |  is_rational_function(self, *syms)\n",
      " |      Test whether function is a ratio of two polynomials in the given\n",
      " |      symbols, syms. When syms is not given, all free symbols will be used.\n",
      " |      The rational function does not have to be in expanded or in any kind of\n",
      " |      canonical form.\n",
      " |\n",
      " |      This function returns False for expressions that are \"rational\n",
      " |      functions\" with symbolic exponents.  Thus, you should be able to call\n",
      " |      .as_numer_denom() and apply polynomial algorithms to the result for\n",
      " |      expressions for which this returns True.\n",
      " |\n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', rational_function=True).\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Symbol, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |\n",
      " |      >>> (x/y).is_rational_function()\n",
      " |      True\n",
      " |\n",
      " |      >>> (x**2).is_rational_function()\n",
      " |      True\n",
      " |\n",
      " |      >>> (x/sin(y)).is_rational_function(y)\n",
      " |      False\n",
      " |\n",
      " |      >>> n = Symbol('n', integer=True)\n",
      " |      >>> (x**n + 1).is_rational_function(x)\n",
      " |      False\n",
      " |\n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a rational function\n",
      " |      to become one.\n",
      " |\n",
      " |      >>> from sympy import sqrt, factor\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)/y\n",
      " |      >>> a.is_rational_function(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      (y + 1)/y\n",
      " |      >>> factor(a).is_rational_function(y)\n",
      " |      True\n",
      " |\n",
      " |      See also is_algebraic_expr().\n",
      " |\n",
      " |  leadterm(self, x, logx=None, cdir=0)\n",
      " |      Returns the leading term a*x**b as a tuple (a, b).\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1+x+x**2).leadterm(x)\n",
      " |      (1, 0)\n",
      " |      >>> (1/x**2+x+x**2).leadterm(x)\n",
      " |      (1, -2)\n",
      " |\n",
      " |  limit(self, x, xlim, dir='+')\n",
      " |      Compute limit x->xlim.\n",
      " |\n",
      " |  lseries(self, x=None, x0=0, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper for series yielding an iterator of the terms of the series.\n",
      " |\n",
      " |      Note: an infinite series will yield an infinite iterator. The following,\n",
      " |      for exaxmple, will never terminate. It will just keep printing terms\n",
      " |      of the sin(x) series::\n",
      " |\n",
      " |        for term in sin(x).lseries(x):\n",
      " |            print term\n",
      " |\n",
      " |      The advantage of lseries() over nseries() is that many times you are\n",
      " |      just interested in the next term in the series (i.e. the first term for\n",
      " |      example), but you do not know how many you should ask for in nseries()\n",
      " |      using the \"n\" parameter.\n",
      " |\n",
      " |      See also nseries().\n",
      " |\n",
      " |  normal(self)\n",
      " |      Return the expression as a fraction.\n",
      " |\n",
      " |      expression -> a/b\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      as_numer_denom: return ``(a, b)`` instead of ``a/b``\n",
      " |\n",
      " |  nseries(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper to _eval_nseries if assumptions allow, else to series.\n",
      " |\n",
      " |      If x is given, x0 is 0, dir='+', and self has x, then _eval_nseries is\n",
      " |      called. This calculates \"n\" terms in the innermost expressions and\n",
      " |      then builds up the final series just by \"cross-multiplying\" everything\n",
      " |      out.\n",
      " |\n",
      " |      The optional ``logx`` parameter can be used to replace any log(x) in the\n",
      " |      returned series with a symbolic value to avoid evaluating log(x) at 0. A\n",
      " |      symbol to use in place of log(x) should be provided.\n",
      " |\n",
      " |      Advantage -- it's fast, because we do not have to determine how many\n",
      " |      terms we need to calculate in advance.\n",
      " |\n",
      " |      Disadvantage -- you may end up with less terms than you may have\n",
      " |      expected, but the O(x**n) term appended will always be correct and\n",
      " |      so the result, though perhaps shorter, will also be correct.\n",
      " |\n",
      " |      If any of those assumptions is not met, this is treated like a\n",
      " |      wrapper to series which will try harder to return the correct\n",
      " |      number of terms.\n",
      " |\n",
      " |      See also lseries().\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import sin, log, Symbol\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> sin(x).nseries(x, 0, 6)\n",
      " |      x - x**3/6 + x**5/120 + O(x**6)\n",
      " |      >>> log(x+1).nseries(x, 0, 5)\n",
      " |      x - x**2/2 + x**3/3 - x**4/4 + O(x**5)\n",
      " |\n",
      " |      Handling of the ``logx`` parameter --- in the following example the\n",
      " |      expansion fails since ``sin`` does not have an asymptotic expansion\n",
      " |      at -oo (the limit of log(x) as x approaches 0):\n",
      " |\n",
      " |      >>> e = sin(log(x))\n",
      " |      >>> e.nseries(x, 0, 6)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      PoleError: ...\n",
      " |      ...\n",
      " |      >>> logx = Symbol('logx')\n",
      " |      >>> e.nseries(x, 0, 6, logx=logx)\n",
      " |      sin(logx)\n",
      " |\n",
      " |      In the following example, the expansion works but only returns self\n",
      " |      unless the ``logx`` parameter is used:\n",
      " |\n",
      " |      >>> e = x**y\n",
      " |      >>> e.nseries(x, 0, 2)\n",
      " |      x**y\n",
      " |      >>> e.nseries(x, 0, 2, logx=logx)\n",
      " |      exp(logx*y)\n",
      " |\n",
      " |  nsimplify(self, constants=(), tolerance=None, full=False)\n",
      " |      See the nsimplify function in sympy.simplify\n",
      " |\n",
      " |  powsimp(self, *args, **kwargs)\n",
      " |      See the powsimp function in sympy.simplify\n",
      " |\n",
      " |  primitive(self)\n",
      " |      Return the positive Rational that can be extracted non-recursively\n",
      " |      from every term of self (i.e., self is treated like an Add). This is\n",
      " |      like the as_coeff_Mul() method but primitive always extracts a positive\n",
      " |      Rational (never a negative or a Float).\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (3*(x + 1)**2).primitive()\n",
      " |      (3, (x + 1)**2)\n",
      " |      >>> a = (6*x + 2); a.primitive()\n",
      " |      (2, 3*x + 1)\n",
      " |      >>> b = (x/2 + 3); b.primitive()\n",
      " |      (1/2, x + 6)\n",
      " |      >>> (a*b).primitive() == (1, a*b)\n",
      " |      True\n",
      " |\n",
      " |  radsimp(self, **kwargs)\n",
      " |      See the radsimp function in sympy.simplify\n",
      " |\n",
      " |  ratsimp(self)\n",
      " |      See the ratsimp function in sympy.simplify\n",
      " |\n",
      " |  removeO(self)\n",
      " |      Removes the additive O(..) symbol if there is one\n",
      " |\n",
      " |  round(self, n=None)\n",
      " |      Return x rounded to the given decimal place.\n",
      " |\n",
      " |      If a complex number would results, apply round to the real\n",
      " |      and imaginary components of the number.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import pi, E, I, S, Number\n",
      " |      >>> pi.round()\n",
      " |      3\n",
      " |      >>> pi.round(2)\n",
      " |      3.14\n",
      " |      >>> (2*pi + E*I).round()\n",
      " |      6 + 3*I\n",
      " |\n",
      " |      The round method has a chopping effect:\n",
      " |\n",
      " |      >>> (2*pi + I/10).round()\n",
      " |      6\n",
      " |      >>> (pi/10 + 2*I).round()\n",
      " |      2*I\n",
      " |      >>> (pi/10 + E*I).round(2)\n",
      " |      0.31 + 2.72*I\n",
      " |\n",
      " |      Notes\n",
      " |      =====\n",
      " |\n",
      " |      The Python ``round`` function uses the SymPy ``round`` method so it\n",
      " |      will always return a SymPy number (not a Python float or int):\n",
      " |\n",
      " |      >>> isinstance(round(S(123), -2), Number)\n",
      " |      True\n",
      " |\n",
      " |  separate(self, deep=False, force=False)\n",
      " |      See the separate function in sympy.simplify\n",
      " |\n",
      " |  series(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Series expansion of \"self\" around ``x = x0`` yielding either terms of\n",
      " |      the series one by one (the lazy series given when n=None), else\n",
      " |      all the terms at once when n != None.\n",
      " |\n",
      " |      Returns the series expansion of \"self\" around the point ``x = x0``\n",
      " |      with respect to ``x`` up to ``O((x - x0)**n, x, x0)`` (default n is 6).\n",
      " |\n",
      " |      If ``x=None`` and ``self`` is univariate, the univariate symbol will\n",
      " |      be supplied, otherwise an error will be raised.\n",
      " |\n",
      " |      Parameters\n",
      " |      ==========\n",
      " |\n",
      " |      expr : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |\n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |\n",
      " |      x0 : Value\n",
      " |           The value around which ``x`` is calculated. Can be any value\n",
      " |           from ``-oo`` to ``oo``.\n",
      " |\n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |\n",
      " |      dir : String, optional\n",
      " |            The series-expansion can be bi-directional. If ``dir=\"+\"``,\n",
      " |            then (x->x0+). If ``dir=\"-\", then (x->x0-). For infinite\n",
      " |            ``x0`` (``oo`` or ``-oo``), the ``dir`` argument is determined\n",
      " |            from the direction of the infinity (i.e., ``dir=\"-\"`` for\n",
      " |            ``oo``).\n",
      " |\n",
      " |      logx : optional\n",
      " |             It is used to replace any log(x) in the returned series with a\n",
      " |             symbolic value rather than evaluating the actual value.\n",
      " |\n",
      " |      cdir : optional\n",
      " |             It stands for complex direction, and indicates the direction\n",
      " |             from which the expansion needs to be evaluated.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import cos, exp, tan\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> cos(x).series()\n",
      " |      1 - x**2/2 + x**4/24 + O(x**6)\n",
      " |      >>> cos(x).series(n=4)\n",
      " |      1 - x**2/2 + O(x**4)\n",
      " |      >>> cos(x).series(x, x0=1, n=2)\n",
      " |      cos(1) - (x - 1)*sin(1) + O((x - 1)**2, (x, 1))\n",
      " |      >>> e = cos(x + exp(y))\n",
      " |      >>> e.series(y, n=2)\n",
      " |      cos(x + 1) - y*sin(x + 1) + O(y**2)\n",
      " |      >>> e.series(x, n=2)\n",
      " |      cos(exp(y)) - x*sin(exp(y)) + O(x**2)\n",
      " |\n",
      " |      If ``n=None`` then a generator of the series terms will be returned.\n",
      " |\n",
      " |      >>> term=cos(x).series(n=None)\n",
      " |      >>> [next(term) for i in range(2)]\n",
      " |      [1, -x**2/2]\n",
      " |\n",
      " |      For ``dir=+`` (default) the series is calculated from the right and\n",
      " |      for ``dir=-`` the series from the left. For smooth functions this\n",
      " |      flag will not alter the results.\n",
      " |\n",
      " |      >>> abs(x).series(dir=\"+\")\n",
      " |      x\n",
      " |      >>> abs(x).series(dir=\"-\")\n",
      " |      -x\n",
      " |      >>> f = tan(x)\n",
      " |      >>> f.series(x, 2, 6, \"+\")\n",
      " |      tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +\n",
      " |      (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +\n",
      " |      5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +\n",
      " |      2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))\n",
      " |\n",
      " |      >>> f.series(x, 2, 3, \"-\")\n",
      " |      tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))\n",
      " |      + O((x - 2)**3, (x, 2))\n",
      " |\n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).series(x, n=8)\n",
      " |      1/x\n",
      " |\n",
      " |      Returns\n",
      " |      =======\n",
      " |\n",
      " |      Expr : Expression\n",
      " |          Series expansion of the expression about x0\n",
      " |\n",
      " |      Raises\n",
      " |      ======\n",
      " |\n",
      " |      TypeError\n",
      " |          If \"n\" and \"x0\" are infinity objects\n",
      " |\n",
      " |      PoleError\n",
      " |          If \"x0\" is an infinity object\n",
      " |\n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import S, I\n",
      " |\n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |\n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |\n",
      " |  taylor_term(self, n, x, *previous_terms)\n",
      " |      General method for the taylor term.\n",
      " |\n",
      " |      This method is slow, because it differentiates n-times. Subclasses can\n",
      " |      redefine it to make it faster by using the \"previous_terms\".\n",
      " |\n",
      " |  together(self, *args, **kwargs)\n",
      " |      See the together function in sympy.polys\n",
      " |\n",
      " |  transpose(self)\n",
      " |\n",
      " |  trigsimp(self, **args)\n",
      " |      See the trigsimp function in sympy.simplify\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.expr.Expr:\n",
      " |\n",
      " |  expr_free_symbols\n",
      " |      Like ``free_symbols``, but returns the free symbols only if\n",
      " |      they are contained in an expression node.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (x + y).expr_free_symbols # doctest: +SKIP\n",
      " |      {x, y}\n",
      " |\n",
      " |      If the expression is contained in a non-expression object, do not return\n",
      " |      the free symbols. Compare:\n",
      " |\n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> t = Tuple(x + y)\n",
      " |      >>> t.expr_free_symbols # doctest: +SKIP\n",
      " |      set()\n",
      " |      >>> t.free_symbols\n",
      " |      {x, y}\n",
      " |\n",
      " |  is_number\n",
      " |      Returns True if ``self`` has no free symbols and no\n",
      " |      undefined functions (AppliedUndef, to be precise). It will be\n",
      " |      faster than ``if not self.free_symbols``, however, since\n",
      " |      ``is_number`` will fail as soon as it hits a free symbol\n",
      " |      or undefined function.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Function, Integral, cos, sin, pi\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> f = Function('f')\n",
      " |\n",
      " |      >>> x.is_number\n",
      " |      False\n",
      " |      >>> f(1).is_number\n",
      " |      False\n",
      " |      >>> (2*x).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, x)).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, (x, 1, 2))).is_number\n",
      " |      True\n",
      " |\n",
      " |      Not all numbers are Numbers in the SymPy sense:\n",
      " |\n",
      " |      >>> pi.is_number, pi.is_Number\n",
      " |      (True, False)\n",
      " |\n",
      " |      If something is a number it should evaluate to a number with\n",
      " |      real and imaginary parts that are Numbers; the result may not\n",
      " |      be comparable, however, since the real and/or imaginary part\n",
      " |      of the result may not have precision.\n",
      " |\n",
      " |      >>> cos(1).is_number and cos(1).is_comparable\n",
      " |      True\n",
      " |\n",
      " |      >>> z = cos(1)**2 + sin(1)**2 - 1\n",
      " |      >>> z.is_number\n",
      " |      True\n",
      " |      >>> z.is_comparable\n",
      " |      False\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      sympy.core.basic.Basic.is_comparable\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.expr.Expr:\n",
      " |\n",
      " |  is_scalar = True\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |\n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |\n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |\n",
      " |      Notes\n",
      " |      =====\n",
      " |\n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |\n",
      " |      References\n",
      " |      ==========\n",
      " |\n",
      " |      from https://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |\n",
      " |  __getnewargs__(self)\n",
      " |\n",
      " |  __getstate__(self)\n",
      " |      Helper for pickle.\n",
      " |\n",
      " |  __hash__(self) -> 'int'\n",
      " |      Return hash(self).\n",
      " |\n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |\n",
      " |      this is the same as:\n",
      " |\n",
      " |      ``a.compare(b) != 0``\n",
      " |\n",
      " |      but faster\n",
      " |\n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |\n",
      " |  __setstate__(self, state)\n",
      " |\n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |\n",
      " |      Notes\n",
      " |      =====\n",
      " |\n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |\n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |\n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |\n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |\n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |\n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |\n",
      " |      The type can be given implicitly, too:\n",
      " |\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |\n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |\n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |\n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |\n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |\n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |\n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |\n",
      " |  copy(self)\n",
      " |\n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |\n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |\n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |\n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |\n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |\n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |\n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |\n",
      " |      >>> u = Dummy('u')\n",
      " |\n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |\n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |\n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |\n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |\n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |\n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |\n",
      " |\n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |\n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |\n",
      " |  has_free(self, *patterns)\n",
      " |      Return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |\n",
      " |      This works for subexpressions and types, too:\n",
      " |\n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |\n",
      " |  has_xfree(self, s: 'set[Basic]')\n",
      " |      Return True if self has any of the patterns in s as a\n",
      " |      free argument, else False. This is like `Basic.has_free`\n",
      " |      but this will only report exact argument matches.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> f(x).has_xfree({f})\n",
      " |      False\n",
      " |      >>> f(x).has_xfree({f(x)})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x + 1})\n",
      " |      True\n",
      " |      >>> f(x + y + 1).has_xfree({x + 1})\n",
      " |      False\n",
      " |\n",
      " |  is_hypergeometric(self, k)\n",
      " |\n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |\n",
      " |      Wild symbols match all.\n",
      " |\n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |\n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |\n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |\n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |\n",
      " |      But they can be identified if desired:\n",
      " |\n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |\n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |\n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |\n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |\n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |\n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |\n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |\n",
      " |      however, you can use:\n",
      " |\n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |\n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |\n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |\n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |\n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |\n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |\n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      Initial setup\n",
      " |\n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |\n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |\n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |\n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |\n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |\n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |\n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |\n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |\n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |\n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |\n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |\n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |\n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |\n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |\n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |\n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |\n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |\n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |\n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |\n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |\n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |\n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |\n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |\n",
      " |      Here, we want `exact=False`:\n",
      " |\n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |\n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |\n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |\n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |\n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |\n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |\n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |\n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |\n",
      " |      Parameters\n",
      " |      ==========\n",
      " |\n",
      " |      args : Expr\n",
      " |          A *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |\n",
      " |      deep : bool, optional\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |\n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |\n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |\n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |\n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |\n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |\n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |\n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |\n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |\n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |\n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |\n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |\n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |\n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |\n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |\n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |\n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |\n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |\n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |\n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |\n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |\n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |\n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |\n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |\n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |\n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |\n",
      " |      rather than\n",
      " |\n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |\n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |\n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |\n",
      " |  xreplace lambda rule, **_ from sympy.core.function.FunctionClass.xreplace.<locals>\n",
      " |      # Function needs args so we define a property that returns\n",
      " |      # a function that takes args...and then use that function\n",
      " |      # to return the right value\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |\n",
      " |  __init_subclass__()\n",
      " |      This method is called when a class is subclassed.\n",
      " |\n",
      " |      The default implementation does nothing. It may be\n",
      " |      overridden to extend subclasses.\n",
      " |\n",
      " |  fromiter(args, **assumptions)\n",
      " |      Create a new object from an iterable.\n",
      " |\n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |\n",
      " |  __sympy__\n",
      " |\n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |\n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |\n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |\n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |\n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |\n",
      " |      Notes\n",
      " |      =====\n",
      " |\n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |\n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |\n",
      " |      For example:\n",
      " |\n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |\n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |\n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |\n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |\n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |\n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |\n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |\n",
      " |  is_antihermitian\n",
      " |\n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |\n",
      " |      Examples\n",
      " |      ========\n",
      " |\n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |\n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |\n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |\n",
      " |  is_composite\n",
      " |\n",
      " |  is_even\n",
      " |\n",
      " |  is_extended_negative\n",
      " |\n",
      " |  is_extended_nonnegative\n",
      " |\n",
      " |  is_extended_nonpositive\n",
      " |\n",
      " |  is_extended_nonzero\n",
      " |\n",
      " |  is_extended_positive\n",
      " |\n",
      " |  is_negative\n",
      " |\n",
      " |  is_nonnegative\n",
      " |\n",
      " |  is_nonpositive\n",
      " |\n",
      " |  is_nonzero\n",
      " |\n",
      " |  is_odd\n",
      " |\n",
      " |  is_polar\n",
      " |\n",
      " |  is_positive\n",
      " |\n",
      " |  is_prime\n",
      " |\n",
      " |  is_zero\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |\n",
      " |  is_Add = False\n",
      " |\n",
      " |  is_AlgebraicNumber = False\n",
      " |\n",
      " |  is_Atom = False\n",
      " |\n",
      " |  is_Boolean = False\n",
      " |\n",
      " |  is_Derivative = False\n",
      " |\n",
      " |  is_Dummy = False\n",
      " |\n",
      " |  is_Equality = False\n",
      " |\n",
      " |  is_Float = False\n",
      " |\n",
      " |  is_Indexed = False\n",
      " |\n",
      " |  is_Integer = False\n",
      " |\n",
      " |  is_MatAdd = False\n",
      " |\n",
      " |  is_MatMul = False\n",
      " |\n",
      " |  is_Matrix = False\n",
      " |\n",
      " |  is_Mul = False\n",
      " |\n",
      " |  is_Not = False\n",
      " |\n",
      " |  is_Number = False\n",
      " |\n",
      " |  is_NumberSymbol = False\n",
      " |\n",
      " |  is_Order = False\n",
      " |\n",
      " |  is_Piecewise = False\n",
      " |\n",
      " |  is_Point = False\n",
      " |\n",
      " |  is_Poly = False\n",
      " |\n",
      " |  is_Pow = False\n",
      " |\n",
      " |  is_Rational = False\n",
      " |\n",
      " |  is_Relational = False\n",
      " |\n",
      " |  is_Symbol = False\n",
      " |\n",
      " |  is_Vector = False\n",
      " |\n",
      " |  is_Wild = False\n",
      " |\n",
      " |  is_symbol = False\n",
      " |\n",
      " |  kind = UndefinedKind\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |\n",
      " |  __repr__ = __str__(self)\n",
      " |\n",
      " |  __str__(self) from sympy.core._print_helpers.Printable\n",
      " |      Return str(self).\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |\n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |\n",
      " |      Parameters\n",
      " |      ==========\n",
      " |\n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |\n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |\n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |\n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |\n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |\n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |\n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |\n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |\n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |\n",
      " |      Notes\n",
      " |      =====\n",
      " |\n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |\n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |\n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |\n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(KroneckerDelta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "learn-sympy",
   "language": "python",
   "name": "learn-sympy"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
